From f180c666d298a4b669fe42b47f7b4dce39aa9c6e Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Thu, 2 Apr 2020 20:12:03 +0200 Subject: [PATCH 01/17] rename some functions --- Project.toml | 2 +- src/Plots.jl | 4 +- src/args.jl | 22 +++--- src/axes.jl | 2 +- src/pipeline.jl | 131 +++++++++++++++--------------- src/plot.jl | 6 +- src/series.jl | 206 +++++++++++++++++++++++++++++------------------- src/utils.jl | 4 +- 8 files changed, 212 insertions(+), 165 deletions(-) diff --git a/Project.toml b/Project.toml index 41c40181..0f4fb1d8 100644 --- a/Project.toml +++ b/Project.toml @@ -44,7 +44,7 @@ PlotThemes = "1" PlotUtils = "0.6.5" RecipesBase = "1" Reexport = "0.2" -Requires = "0.5, 1.0" +Requires = "0.5, 1" Showoff = "0.3.1" StatsBase = "0.32, 0.33" julia = "1" diff --git a/src/Plots.jl b/src/Plots.jl index 5c960e19..494d1da9 100644 --- a/src/Plots.jl +++ b/src/Plots.jl @@ -226,7 +226,7 @@ end const CURRENT_BACKEND = CurrentBackend(:none) -include("precompile.jl") -_precompile_() +# include("precompile.jl") +# _precompile_() end # module diff --git a/src/args.jl b/src/args.jl index a24d7de6..000ba22e 100644 --- a/src/args.jl +++ b/src/args.jl @@ -685,7 +685,7 @@ end function default(; kw...) kw = KW(kw) - preprocessArgs!(kw) + preprocess_attributes!(kw) for (k,v) in kw default(k, v) end @@ -938,7 +938,7 @@ function _add_markershape(plotattributes::AKW) end "Handle all preprocessing of args... break out colors/sizes/etc and replace aliases." -function preprocessArgs!(plotattributes::AKW) +function preprocess_attributes!(plotattributes::AKW) replaceAliases!(plotattributes, _keyAliases) # handle axis args common to all axis @@ -1125,7 +1125,7 @@ end # this is when given a vector-type of values to group by -function extractGroupArgs(v::AVec, args...; legendEntry = string) +function _extract_group_attributes(v::AVec, args...; legendEntry = string) groupLabels = sort(collect(unique(v))) n = length(groupLabels) if n > 100 @@ -1138,24 +1138,24 @@ end legendEntryFromTuple(ns::Tuple) = join(ns, ' ') # this is when given a tuple of vectors of values to group by -function extractGroupArgs(vs::Tuple, args...) +function _extract_group_attributes(vs::Tuple, args...) isempty(vs) && return GroupBy([""], [axes(args[1],1)]) v = map(tuple, vs...) - extractGroupArgs(v, args...; legendEntry = legendEntryFromTuple) + _extract_group_attributes(v, args...; legendEntry = legendEntryFromTuple) end # allow passing NamedTuples for a named legend entry legendEntryFromTuple(ns::NamedTuple) = join(["$k = $v" for (k, v) in pairs(ns)], ", ") -function extractGroupArgs(vs::NamedTuple, args...) +function _extract_group_attributes(vs::NamedTuple, args...) isempty(vs) && return GroupBy([""], [axes(args[1],1)]) v = map(NamedTuple{keys(vs)}∘tuple, values(vs)...) - extractGroupArgs(v, args...; legendEntry = legendEntryFromTuple) + _extract_group_attributes(v, args...; legendEntry = legendEntryFromTuple) end # expecting a mapping of "group label" to "group indices" -function extractGroupArgs(idxmap::Dict{T,V}, args...) where {T, V<:AVec{Int}} +function _extract_group_attributes(idxmap::Dict{T,V}, args...) where {T, V<:AVec{Int}} groupLabels = sortedkeys(idxmap) groupIds = Vector{Int}[collect(idxmap[k]) for k in groupLabels] GroupBy(groupLabels, groupIds) @@ -1183,7 +1183,7 @@ end const _already_warned = Dict{Symbol,Set{Symbol}}() const _to_warn = Set{Symbol}() -function warnOnUnsupported_args(pkg::AbstractBackend, plotattributes) +function warn_on_unsupported_args(pkg::AbstractBackend, plotattributes) empty!(_to_warn) bend = backend_name(pkg) already_warned = get!(_already_warned, bend, Set{Symbol}()) @@ -1207,7 +1207,7 @@ end # _markershape_supported(pkg::AbstractBackend, shape::Shape) = Shape in supported_markers(pkg) # _markershape_supported(pkg::AbstractBackend, shapes::AVec) = all([_markershape_supported(pkg, shape) for shape in shapes]) -function warnOnUnsupported(pkg::AbstractBackend, plotattributes) +function warn_on_unsupported(pkg::AbstractBackend, plotattributes) if !is_seriestype_supported(pkg, plotattributes[:seriestype]) @warn("seriestype $(plotattributes[:seriestype]) is unsupported with $pkg. Choose from: $(supported_seriestypes(pkg))") end @@ -1219,7 +1219,7 @@ function warnOnUnsupported(pkg::AbstractBackend, plotattributes) end end -function warnOnUnsupported_scales(pkg::AbstractBackend, plotattributes::AKW) +function warn_on_unsupported_scales(pkg::AbstractBackend, plotattributes::AKW) for k in (:xscale, :yscale, :zscale, :scale) if haskey(plotattributes, k) v = plotattributes[k] diff --git a/src/axes.jl b/src/axes.jl index 822de875..15e93b1f 100644 --- a/src/axes.jl +++ b/src/axes.jl @@ -85,7 +85,7 @@ function attr!(axis::Axis, args...; kw...) end # then preprocess keyword arguments - preprocessArgs!(KW(kw)) + preprocess_attributes!(KW(kw)) # then override for any keywords... only those keywords that already exists in plotattributes for (k,v) in kw diff --git a/src/pipeline.jl b/src/pipeline.jl index e6256edc..8325d86a 100644 --- a/src/pipeline.jl +++ b/src/pipeline.jl @@ -38,7 +38,7 @@ function _expand_seriestype_array(plotattributes::AKW, args) rd = Vector{RecipeData}(undef, size(sts, 1)) for r in axes(sts, 1) dc = copy(plotattributes) - dc[:seriestype] = sts[r:r,:] + dc[:seriestype] = sts[r:r, :] rd[r] = RecipeData(dc, args) end rd @@ -52,7 +52,7 @@ function _preprocess_args(plotattributes::AKW, args, still_to_process::Vector{Re # we simply add the GroupBy object to the front of the args list to allow # the recipe to be applied if haskey(plotattributes, :group) - args = (extractGroupArgs(plotattributes[:group], args...), args...) + args = (_extract_group_attributes(plotattributes[:group], args...), args...) end # if we were passed a vector/matrix of seriestypes and there's more than one row, @@ -61,9 +61,10 @@ function _preprocess_args(plotattributes::AKW, args, still_to_process::Vector{Re append!(still_to_process, _expand_seriestype_array(plotattributes, args)) end - # remove subplot and axis args from plotattributes... they will be passed through in the kw_list + # remove subplot and axis args from plotattributes... + # they will be passed through in the kw_list if !isempty(args) - for (k,v) in plotattributes + for (k, v) in plotattributes if k in _all_subplot_args || k in _all_axis_args reset_kw!(plotattributes, k) end @@ -90,22 +91,21 @@ function _process_userrecipes(plt::Plot, plotattributes::AKW, args) kw_list = KW[] while !isempty(still_to_process) # grab the first in line to be processed and either add it to the kw_list or - # pass it through apply_recipe to generate a list of RecipeData objects (data + attributes) - # for further processing. + # pass it through apply_recipe to generate a list of RecipeData objects + # (data + attributes) for further processing. next_series = popfirst!(still_to_process) - # recipedata should be of type RecipeData. if it's not then the inputs must not have been fully processed by recipes + # recipedata should be of type RecipeData. + # if it's not then the inputs must not have been fully processed by recipes if !(typeof(next_series) <: RecipeData) error("Inputs couldn't be processed... expected RecipeData but got: $next_series") end if isempty(next_series.args) _process_userrecipe(plt, kw_list, next_series) else - rd_list = RecipesBase.apply_recipe( - next_series.plotattributes, - next_series.args... - ) + rd_list = + RecipesBase.apply_recipe(next_series.plotattributes, next_series.args...) warn_on_recipe_aliases!(rd_list, :user, next_series.args...) - prepend!(still_to_process,rd_list) + prepend!(still_to_process, rd_list) end end @@ -118,9 +118,9 @@ function _process_userrecipe(plt::Plot, kw_list::Vector{KW}, recipedata::RecipeD # when the arg tuple is empty, that means there's nothing left to recursively # process... finish up and add to the kw_list kw = recipedata.plotattributes - preprocessArgs!(kw) + preprocess_attributes!(kw) _preprocess_userrecipe(kw) - warnOnUnsupported_scales(plt.backend, kw) + warn_on_unsupported_scales(plt.backend, kw) # add the plot index plt.n += 1 @@ -141,12 +141,14 @@ function _preprocess_userrecipe(kw::AKW) # map marker_z if it's a Function if isa(get(kw, :marker_z, nothing), Function) # TODO: should this take y and/or z as arguments? - kw[:marker_z] = isa(kw[:z], Nothing) ? map(kw[:marker_z], kw[:x], kw[:y]) : map(kw[:marker_z], kw[:x], kw[:y], kw[:z]) + kw[:marker_z] = isa(kw[:z], Nothing) ? map(kw[:marker_z], kw[:x], kw[:y]) : + map(kw[:marker_z], kw[:x], kw[:y], kw[:z]) end # map line_z if it's a Function if isa(get(kw, :line_z, nothing), Function) - kw[:line_z] = isa(kw[:z], Nothing) ? map(kw[:line_z], kw[:x], kw[:y]) : map(kw[:line_z], kw[:x], kw[:y], kw[:z]) + kw[:line_z] = isa(kw[:z], Nothing) ? map(kw[:line_z], kw[:x], kw[:y]) : + map(kw[:line_z], kw[:x], kw[:y], kw[:z]) end # convert a ribbon into a fillrange @@ -178,14 +180,20 @@ function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW) β, α = convert(Matrix{Float64}, [x ones(length(x))]) \ convert(Vector{Float64}, y) sx = [ignorenan_minimum(x), ignorenan_maximum(x)] sy = β .* sx .+ α - push!(kw_list, merge(copy(kw), KW( - :seriestype => :path, - :x => sx, - :y => sy, - :fillrange => nothing, - :label => "", - :primary => false, - ))) + push!( + kw_list, + merge( + copy(kw), + KW( + :seriestype => :path, + :x => sx, + :y => sy, + :fillrange => nothing, + :label => "", + :primary => false, + ), + ), + ) end end @@ -196,7 +204,12 @@ end # to generate a list of RecipeData objects (data + attributes). # If we applied a "plot recipe" without error, then add the returned datalist's KWs, # otherwise we just add the original KW. -function _process_plotrecipe(plt::Plot, kw::AKW, kw_list::Vector{KW}, still_to_process::Vector{KW}) +function _process_plotrecipe( + plt::Plot, + kw::AKW, + kw_list::Vector{KW}, + still_to_process::Vector{KW}, +) if !isa(get(kw, :seriestype, nothing), Symbol) # seriestype was never set, or it's not a Symbol, so it can't be a plot recipe push!(kw_list, kw) @@ -208,7 +221,7 @@ function _process_plotrecipe(plt::Plot, kw::AKW, kw_list::Vector{KW}, still_to_p datalist = RecipesBase.apply_recipe(kw, Val{st}, plt) warn_on_recipe_aliases!(datalist, :plot, st) for data in datalist - preprocessArgs!(data.plotattributes) + preprocess_attributes!(data.plotattributes) if data.plotattributes[:seriestype] == st error("Plot recipe $st returned the same seriestype: $(data.plotattributes)") end @@ -230,7 +243,7 @@ end function _plot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW}) # merge in anything meant for the Plot - for kw in kw_list, (k,v) in kw + for kw in kw_list, (k, v) in kw haskey(_plot_defaults, k) && (plotattributes[k] = pop!(kw, k)) end @@ -241,7 +254,7 @@ function _plot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW}) # create the layout and subplots from the inputs plt.layout, plt.subplots, plt.spmap = build_layout(plt.attr) - for (idx,sp) in enumerate(plt.subplots) + for (idx, sp) in enumerate(plt.subplots) sp.plt = plt sp.attr[:subplot_index] = idx end @@ -266,7 +279,7 @@ function _plot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW}) else parent = plt.layout end - sp = Subplot(backend(), parent=parent) + sp = Subplot(backend(), parent = parent) sp.plt = plt push!(plt.subplots, sp) push!(plt.inset_subplots, sp) @@ -282,28 +295,34 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW}) # Subplot/Axis attributes set by a user/series recipe apply only to the # Subplot object which they belong to. # TODO: allow matrices to still apply to all subplots - sp_attrs = Dict{Subplot,Any}() + sp_attrs = Dict{Subplot, Any}() for kw in kw_list # get the Subplot object to which the series belongs. sps = get(kw, :subplot, :auto) - sp = get_subplot(plt, _cycle(sps == :auto ? plt.subplots : plt.subplots[sps], series_idx(kw_list,kw))) + sp = get_subplot( + plt, + _cycle( + sps == :auto ? plt.subplots : plt.subplots[sps], + series_idx(kw_list, kw), + ), + ) kw[:subplot] = sp # extract subplot/axis attributes from kw and add to sp_attr attr = KW() - for (k,v) in collect(kw) + for (k, v) in collect(kw) if is_subplot_attr(k) || is_axis_attr(k) attr[k] = pop!(kw, k) end if is_axis_attr_noletter(k) v = pop!(kw, k) - for letter in (:x,:y,:z) - attr[Symbol(letter,k)] = v + for letter in (:x, :y, :z) + attr[Symbol(letter, k)] = v end end - for k in (:scale,), letter in (:x,:y,:z) + for k in (:scale,), letter in (:x, :y, :z) # Series recipes may need access to this information - lk = Symbol(letter,k) + lk = Symbol(letter, k) if haskey(attr, lk) kw[lk] = attr[lk] end @@ -313,7 +332,7 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW}) end # override subplot/axis args. `sp_attrs` take precendence - for (idx,sp) in enumerate(plt.subplots) + for (idx, sp) in enumerate(plt.subplots) attr = if !haskey(plotattributes, :subplot) || plotattributes[:subplot] == idx merge(plotattributes, get(sp_attrs, sp, KW())) else @@ -328,7 +347,7 @@ end # getting ready to add the series... last update to subplot from anything # that might have been added during series recipes -function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where T +function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where {T} st::Symbol = plotattributes[:seriestype] sp::Subplot{T} = plotattributes[:subplot] sp_idx = get_subplot_index(plt, sp) @@ -354,9 +373,10 @@ end function _override_seriestype_check(plotattributes::AKW, st::Symbol) # do we want to override the series type? - if !is3d(st) && !(st in (:contour,:contour3d)) + if !is3d(st) && !(st in (:contour, :contour3d)) z = plotattributes[:z] - if !isa(z, Nothing) && (size(plotattributes[:x]) == size(plotattributes[:y]) == size(z)) + if !isa(z, Nothing) && + (size(plotattributes[:x]) == size(plotattributes[:y]) == size(z)) st = (st == :scatter ? :scatter3d : :path3d) plotattributes[:seriestype] = st end @@ -364,27 +384,11 @@ function _override_seriestype_check(plotattributes::AKW, st::Symbol) st end -function _prepare_annotations(sp::Subplot, plotattributes::AKW) - # strip out series annotations (those which are based on series x/y coords) - # and add them to the subplot attr - sp_anns = annotations(sp[:annotations]) - # series_anns = annotations(pop!(plotattributes, :series_annotations, [])) - # if isa(series_anns, SeriesAnnotations) - # series_anns.x = plotattributes[:x] - # series_anns.y = plotattributes[:y] - # elseif length(series_anns) > 0 - # x, y = plotattributes[:x], plotattributes[:y] - # nx, ny, na = map(length, (x,y,series_anns)) - # n = max(nx, ny, na) - # series_anns = [(x[mod1(i,nx)], y[mod1(i,ny)], text(series_anns[mod1(i,na)])) for i=1:n] - # end - # sp.attr[:annotations] = vcat(sp_anns, series_anns) -end - function _expand_subplot_extrema(sp::Subplot, plotattributes::AKW, st::Symbol) # adjust extrema and discrete info if st == :image - xmin, xmax = ignorenan_extrema(plotattributes[:x]); ymin, ymax = ignorenan_extrema(plotattributes[:y]) + xmin, xmax = ignorenan_extrema(plotattributes[:x]) + ymin, ymax = ignorenan_extrema(plotattributes[:y]) expand_extrema!(sp[:xaxis], (xmin, xmax)) expand_extrema!(sp[:yaxis], (ymin, ymax)) elseif !(st in (:pie, :histogram, :bins2d, :histogram2d)) @@ -398,8 +402,8 @@ function _expand_subplot_extrema(sp::Subplot, plotattributes::AKW, st::Symbol) end function _add_the_series(plt, sp, plotattributes) - warnOnUnsupported_args(plt.backend, plotattributes) - warnOnUnsupported(plt.backend, plotattributes) + warn_on_unsupported_args(plt.backend, plotattributes) + warn_on_unsupported(plt.backend, plotattributes) series = Series(plotattributes) push!(plt.series_list, series) push!(sp.series_list, series) @@ -411,7 +415,6 @@ end # this method recursively applies series recipes when the seriestype is not supported # natively by the backend function _process_seriesrecipe(plt::Plot, plotattributes::AKW) - #println("process $(typeof(plotattributes))") # replace seriestype aliases st = Symbol(plotattributes[:seriestype]) st = plotattributes[:seriestype] = get(_typeAliases, st, st) @@ -421,10 +424,10 @@ function _process_seriesrecipe(plt::Plot, plotattributes::AKW) plotattributes[:fillrange] = nothing end - # if it's natively supported, finalize processing and pass along to the backend, otherwise recurse + # if it's natively supported, finalize processing and pass along to the backend, + # otherwise recurse if is_seriestype_supported(st) sp = _prepare_subplot(plt, plotattributes) - _prepare_annotations(sp, plotattributes) _expand_subplot_extrema(sp, plotattributes, st) _update_series_attributes!(plotattributes, plt, sp) _add_the_series(plt, sp, plotattributes) @@ -438,7 +441,7 @@ function _process_seriesrecipe(plt::Plot, plotattributes::AKW) # assuming there was no error, recursively apply the series recipes for data in datalist if isa(data, RecipeData) - preprocessArgs!(data.plotattributes) + preprocess_attributes!(data.plotattributes) if data.plotattributes[:seriestype] == st error("The seriestype didn't change in series recipe $st. This will cause a StackOverflow.") end diff --git a/src/plot.jl b/src/plot.jl index 7bd16693..13653fee 100644 --- a/src/plot.jl +++ b/src/plot.jl @@ -49,7 +49,7 @@ as a String to look up its docstring; e.g. `plotattr("seriestype")`. function plot(args...; kw...) # this creates a new plot with args/kw and sets it to be the current plot plotattributes = KW(kw) - preprocessArgs!(plotattributes) + preprocess_attributes!(plotattributes) # create an empty Plot then process plt = Plot() @@ -61,7 +61,7 @@ end # note: we split into plt1 and plts_tail so we can dispatch correctly function plot(plt1::Plot, plts_tail::Plot...; kw...) plotattributes = KW(kw) - preprocessArgs!(plotattributes) + preprocess_attributes!(plotattributes) # build our plot vector from the args n = length(plts_tail) + 1 @@ -153,7 +153,7 @@ end # this adds to a specific plot... most plot commands will flow through here function plot!(plt::Plot, args...; kw...) plotattributes = KW(kw) - preprocessArgs!(plotattributes) + preprocess_attributes!(plotattributes) # merge!(plt.user_attr, plotattributes) _plot!(plt, plotattributes, args) end diff --git a/src/series.jl b/src/series.jl index ff3ce8a7..11cf7493 100644 --- a/src/series.jl +++ b/src/series.jl @@ -11,29 +11,32 @@ const MaybeNumber = Union{Number, Missing} const MaybeString = Union{AbstractString, Missing} const DataPoint = Union{MaybeNumber, MaybeString} -prepareSeriesData(x) = error("Cannot convert $(typeof(x)) to series data for plotting") -prepareSeriesData(::Nothing) = nothing -prepareSeriesData(t::Tuple{T, T}) where {T<:Number} = t -prepareSeriesData(f::Function) = f -prepareSeriesData(ar::AbstractRange{<:Number}) = ar -function prepareSeriesData(a::AbstractArray{<:MaybeNumber}) +prepare_series_data(x) = error("Cannot convert $(typeof(x)) to series data for plotting") +prepare_series_data(::Nothing) = nothing +prepare_series_data(t::Tuple{T, T}) where {T <: Number} = t +prepare_series_data(f::Function) = f +prepare_series_data(ar::AbstractRange{<:Number}) = ar +function prepare_series_data(a::AbstractArray{<:MaybeNumber}) f = isimmutable(a) ? replace : replace! a = f(x -> ismissing(x) || isinf(x) ? NaN : x, map(float, a)) end -prepareSeriesData(a::AbstractArray{<:Missing}) = fill(NaN, axes(a)) -prepareSeriesData(a::AbstractArray{<:MaybeString}) = replace(x -> ismissing(x) ? "" : x, a) -prepareSeriesData(s::Surface{<:AMat{<:MaybeNumber}}) = Surface(prepareSeriesData(s.surf)) -prepareSeriesData(s::Surface) = s # non-numeric Surface, such as an image -prepareSeriesData(v::Volume) = Volume(prepareSeriesData(v.v), v.x_extents, v.y_extents, v.z_extents) +prepare_series_data(a::AbstractArray{<:Missing}) = fill(NaN, axes(a)) +prepare_series_data(a::AbstractArray{<:MaybeString}) = + replace(x -> ismissing(x) ? "" : x, a) +prepare_series_data(s::Surface{<:AMat{<:MaybeNumber}}) = + Surface(prepare_series_data(s.surf)) +prepare_series_data(s::Surface) = s # non-numeric Surface, such as an image +prepare_series_data(v::Volume) = + Volume(prepare_series_data(v.v), v.x_extents, v.y_extents, v.z_extents) # default: assume x represents a single series -series_vector(x, plotattributes) = [prepareSeriesData(x)] +series_vector(x, plotattributes) = [prepare_series_data(x)] # fixed number of blank series series_vector(n::Integer, plotattributes) = [zeros(0) for i in 1:n] # vector of data points is a single series -series_vector(v::AVec{<:DataPoint}, plotattributes) = [prepareSeriesData(v)] +series_vector(v::AVec{<:DataPoint}, plotattributes) = [prepare_series_data(v)] # list of things (maybe other vectors, functions, or something else) function series_vector(v::AVec, plotattributes) @@ -49,9 +52,9 @@ end # Matrix is split into columns function series_vector(v::AMat{<:DataPoint}, plotattributes) if all3D(plotattributes) - [prepareSeriesData(Surface(v))] + [prepare_series_data(Surface(v))] else - [prepareSeriesData(v[:, i]) for i in axes(v, 2)] + [prepare_series_data(v[:, i]) for i in axes(v, 2)] end end @@ -73,35 +76,37 @@ process_ribbon(ribbon::Tuple{S, T}, plotattributes) where {S, T} = collect(zip( # -------------------------------------------------------------------- -compute_x(x::Nothing, y::Nothing, z) = axes(z,1) -compute_x(x::Nothing, y, z) = axes(y,1) -compute_x(x::Function, y, z) = map(x, y) -compute_x(x, y, z) = x +compute_x(x::Nothing, y::Nothing, z) = axes(z, 1) +compute_x(x::Nothing, y, z) = axes(y, 1) +compute_x(x::Function, y, z) = map(x, y) +compute_x(x, y, z) = x -compute_y(x::Nothing, y::Nothing, z) = axes(z,2) -compute_y(x, y::Function, z) = map(y, x) -compute_y(x, y, z) = y +compute_y(x::Nothing, y::Nothing, z) = axes(z, 2) +compute_y(x, y::Function, z) = map(y, x) +compute_y(x, y, z) = y -compute_z(x, y, z::Function) = map(z, x, y) -compute_z(x, y, z::AbstractMatrix) = Surface(z) -compute_z(x, y, z::Nothing) = nothing -compute_z(x, y, z) = z +compute_z(x, y, z::Function) = map(z, x, y) +compute_z(x, y, z::AbstractMatrix) = Surface(z) +compute_z(x, y, z::Nothing) = nothing +compute_z(x, y, z) = z nobigs(v::AVec{BigFloat}) = map(Float64, v) nobigs(v::AVec{BigInt}) = map(Int64, v) nobigs(v) = v @noinline function compute_xyz(x, y, z) - x = compute_x(x,y,z) - y = compute_y(x,y,z) - z = compute_z(x,y,z) + x = compute_x(x, y, z) + y = compute_y(x, y, z) + z = compute_z(x, y, z) nobigs(x), nobigs(y), nobigs(z) end # not allowed -compute_xyz(x::Nothing, y::FuncOrFuncs{F}, z) where {F<:Function} = error("If you want to plot the function `$y`, you need to define the x values!") -compute_xyz(x::Nothing, y::Nothing, z::FuncOrFuncs{F}) where {F<:Function} = error("If you want to plot the function `$z`, you need to define x and y values!") -compute_xyz(x::Nothing, y::Nothing, z::Nothing) = error("x/y/z are all nothing!") +compute_xyz(x::Nothing, y::FuncOrFuncs{F}, z) where {F <: Function} = + error("If you want to plot the function `$y`, you need to define the x values!") +compute_xyz(x::Nothing, y::Nothing, z::FuncOrFuncs{F}) where {F <: Function} = + error("If you want to plot the function `$z`, you need to define x and y values!") +compute_xyz(x::Nothing, y::Nothing, z::Nothing) = error("x/y/z are all nothing!") # -------------------------------------------------------------------- @@ -153,15 +158,15 @@ struct SliceIt end for i in 1:max(mx, my, mz) # add a new series di = copy(plotattributes) - xi, yi, zi = xs[mod1(i,mx)], ys[mod1(i,my)], zs[mod1(i,mz)] + xi, yi, zi = xs[mod1(i, mx)], ys[mod1(i, my)], zs[mod1(i, mz)] di[:x], di[:y], di[:z] = compute_xyz(xi, yi, zi) # handle fillrange - fr = fillranges[mod1(i,mf)] + fr = fillranges[mod1(i, mf)] di[:fillrange] = isa(fr, Function) ? map(fr, di[:x]) : fr # handle ribbons - rib = ribbons[mod1(i,mr)] + rib = ribbons[mod1(i, mr)] di[:ribbon] = isa(rib, Function) ? map(rib, di[:x]) : rib push!(series_list, RecipeData(di, ())) @@ -176,10 +181,11 @@ end # -------------------------------------------------------------------- # this is the default "type recipe"... just pass the object through -@recipe f(::Type{T}, v::T) where T = v +@recipe f(::Type{T}, v::T) where {T} = v # this should catch unhandled "series recipes" and error with a nice message -@recipe f(::Type{V}, x, y, z) where {V<:Val} = error("The backend must not support the series type $V, and there isn't a series recipe defined.") +@recipe f(::Type{V}, x, y, z) where {V <: Val} = + error("The backend must not support the series type $V, and there isn't a series recipe defined.") function _apply_type_recipe(plotattributes, v, letter) _preprocess_axis_args!(plotattributes, letter) @@ -206,9 +212,9 @@ function _apply_type_recipe(plotattributes, v::AbstractArray, letter) _postprocess_axis_args!(plotattributes, letter) if length(args) == 2 && all(arg -> arg isa Function, args) numfunc, formatter = args - return Formatted(map(numfunc, v), formatter) - else - return v + return Formatted(map(numfunc, v), formatter) + else + return v end end _postprocess_axis_args!(plotattributes, letter) @@ -317,13 +323,16 @@ end # so we'll apply_type_recipe to all of them @recipe function f(v1, v2, v3, v4, vrest...) did_replace = false - newargs = map(v -> begin - newv = _apply_type_recipe(plotattributes, v, :unknown) - if newv !== v - did_replace = true - end - newv - end, (v1, v2, v3, v4, vrest...)) + newargs = map( + v -> begin + newv = _apply_type_recipe(plotattributes, v, :unknown) + if newv !== v + did_replace = true + end + newv + end, + (v1, v2, v3, v4, vrest...), + ) if !did_replace error("Couldn't process recipe args: $(map(typeof, (v1, v2, v3, v4, vrest...)))") end @@ -352,7 +361,8 @@ end # 1 argument # -------------------------------------------------------------------- -@recipe f(n::Integer) = is3d(get(plotattributes,:seriestype,:path)) ? (SliceIt, n, n, n) : (SliceIt, n, n, nothing) +@recipe f(n::Integer) = is3d(get(plotattributes, :seriestype, :path)) ? (SliceIt, n, n, n) : + (SliceIt, n, n, nothing) all3D(plotattributes) = trueOrAllTrue( st -> st in ( @@ -416,13 +426,13 @@ end yflip --> true cbar --> false fillcolor --> ColorGradient([:black, :white]) - SliceIt, m, n, Surface(clamp!(convert(Matrix{Float64}, mat), 0., 1.)) + SliceIt, m, n, Surface(clamp!(convert(Matrix{Float64}, mat), 0.0, 1.0)) end end # images - colors -@recipe function f(mat::AMat{T}) where T<:Colorant - n, m = axes(mat) +@recipe function f(mat::AMat{T}) where {T <: Colorant} + n, m = axes(mat) if is_seriestype_supported(:image) seriestype := :image @@ -452,8 +462,8 @@ end @recipe function f(shapes::AMat{Shape}) seriestype --> :shape - for j in axes(shapes,2) - @series coords(vec(shapes[:,j])) + for j in axes(shapes, 2) + @series coords(vec(shapes[:, j])) end end @@ -463,7 +473,7 @@ end # function without range... use the current range of the x-axis -@recipe function f(f::FuncOrFuncs{F}) where F<:Function +@recipe function f(f::FuncOrFuncs{F}) where {F <: Function} plt = plotattributes[:plot_object] xmin, xmax = if haskey(plotattributes, :xlims) plotattributes[:xlims] @@ -472,8 +482,8 @@ end axis_limits(plt[1], :x) catch xinv = invscalefunc(get(plotattributes, :xscale, :identity)) - xm = PlotUtils.tryrange(f, xinv.([-5,-1,0,0.01])) - xm, PlotUtils.tryrange(f, filter(x->x>xm, xinv.([5,1,0.99, 0, -0.01]))) + xm = PlotUtils.tryrange(f, xinv.([-5, -1, 0, 0.01])) + xm, PlotUtils.tryrange(f, filter(x -> x > xm, xinv.([5, 1, 0.99, 0, -0.01]))) end end @@ -488,7 +498,7 @@ end # if functions come first, just swap the order (not to be confused with parametric # functions... as there would be more than one function passed in) -@recipe function f(f::FuncOrFuncs{F}, x) where F<:Function +@recipe function f(f::FuncOrFuncs{F}, x) where {F <: Function} F2 = typeof(x) @assert !(F2 <: Function || (F2 <: AbstractArray && F2.parameters[1] <: Function)) # otherwise we'd hit infinite recursion here x, f @@ -513,7 +523,7 @@ end end # images - grays -@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where T<:Gray +@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where {T <: Gray} if is_seriestype_supported(:image) seriestype := :image yflip --> true @@ -528,7 +538,7 @@ end end # images - colors -@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where T<:Colorant +@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where {T <: Colorant} if is_seriestype_supported(:image) seriestype := :image yflip --> true @@ -549,27 +559,49 @@ end # special handling... xmin/xmax with parametric function(s) @recipe function f(f::Function, xmin::Number, xmax::Number) - xscale, yscale = [get(plotattributes, sym, :identity) for sym=(:xscale,:yscale)] + xscale, yscale = [get(plotattributes, sym, :identity) for sym in (:xscale, :yscale)] _scaled_adapted_grid(f, xscale, yscale, xmin, xmax) end -@recipe function f(fs::AbstractArray{F}, xmin::Number, xmax::Number) where F<:Function - xscale, yscale = [get(plotattributes, sym, :identity) for sym=(:xscale,:yscale)] +@recipe function f(fs::AbstractArray{F}, xmin::Number, xmax::Number) where {F <: Function} + xscale, yscale = [get(plotattributes, sym, :identity) for sym in (:xscale, :yscale)] unzip(_scaled_adapted_grid.(fs, xscale, yscale, xmin, xmax)) end -@recipe f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, u::AVec) where {F<:Function,G<:Function} = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u) -@recipe f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, umin::Number, umax::Number, n = 200) where {F<:Function,G<:Function} = fx, fy, range(umin, stop = umax, length = n) +@recipe f( + fx::FuncOrFuncs{F}, + fy::FuncOrFuncs{G}, + u::AVec, +) where {F <: Function, G <: Function} = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u) +@recipe f( + fx::FuncOrFuncs{F}, + fy::FuncOrFuncs{G}, + umin::Number, + umax::Number, + n = 200, +) where {F <: Function, G <: Function} = fx, fy, range(umin, stop = umax, length = n) function _scaled_adapted_grid(f, xscale, yscale, xmin, xmax) - (xf, xinv), (yf, yinv) = ((scalefunc(s),invscalefunc(s)) for s in (xscale,yscale)) - xs, ys = adapted_grid(yf∘f∘xinv, xf.((xmin, xmax))) + (xf, xinv), (yf, yinv) = ((scalefunc(s), invscalefunc(s)) for s in (xscale, yscale)) + xs, ys = adapted_grid(yf ∘ f ∘ xinv, xf.((xmin, xmax))) xinv.(xs), yinv.(ys) end # special handling... 3D parametric function(s) -@recipe function f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, u::AVec) where {F<:Function,G<:Function,H<:Function} +@recipe function f( + fx::FuncOrFuncs{F}, + fy::FuncOrFuncs{G}, + fz::FuncOrFuncs{H}, + u::AVec, +) where {F <: Function, G <: Function, H <: Function} mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u) end -@recipe function f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, umin::Number, umax::Number, numPoints = 200) where {F<:Function,G<:Function,H<:Function} +@recipe function f( + fx::FuncOrFuncs{F}, + fy::FuncOrFuncs{G}, + fz::FuncOrFuncs{H}, + umin::Number, + umax::Number, + numPoints = 200, +) where {F <: Function, G <: Function, H <: Function} fx, fy, fz, range(umin, stop = umax, length = numPoints) end @@ -578,13 +610,15 @@ end # Lists of tuples and GeometryTypes.Points # -------------------------------------------------------------------- -@recipe f(v::AVec{<:Tuple}) = unzip(v) +@recipe f(v::AVec{<:Tuple}) = unzip(v) @recipe f(v::AVec{<:GeometryTypes.Point}) = unzip(v) -@recipe f(tup::Tuple) = [tup] +@recipe f(tup::Tuple) = [tup] @recipe f(p::GeometryTypes.Point) = [p] # Special case for 4-tuples in :ohlc series -@recipe f(xyuv::AVec{<:Tuple{R1,R2,R3,R4}}) where {R1,R2,R3,R4} = get(plotattributes,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv) +@recipe f(xyuv::AVec{<:Tuple{R1, R2, R3, R4}}) where {R1, R2, R3, R4} = + get(plotattributes, :seriestype, :path) == :ohlc ? OHLC[OHLC(t...) for t in xyuv] : + unzip(xyuv) # -------------------------------------------------------------------- @@ -592,11 +626,13 @@ end # -------------------------------------------------------------------- splittable_kw(key, val, lengthGroup) = false -splittable_kw(key, val::AbstractArray, lengthGroup) = !(key in (:group, :color_palette)) && length(axes(val,1)) == lengthGroup +splittable_kw(key, val::AbstractArray, lengthGroup) = + !(key in (:group, :color_palette)) && length(axes(val, 1)) == lengthGroup splittable_kw(key, val::Tuple, lengthGroup) = all(splittable_kw.(key, val, lengthGroup)) -splittable_kw(key, val::SeriesAnnotations, lengthGroup) = splittable_kw(key, val.strs, lengthGroup) +splittable_kw(key, val::SeriesAnnotations, lengthGroup) = + splittable_kw(key, val.strs, lengthGroup) -split_kw(key, val::AbstractArray, indices) = val[indices, fill(Colon(), ndims(val)-1)...] +split_kw(key, val::AbstractArray, indices) = val[indices, fill(Colon(), ndims(val) - 1)...] split_kw(key, val::Tuple, indices) = Tuple(split_kw(key, v, indices) for v in val) function split_kw(key, val::SeriesAnnotations, indices) split_strs = split_kw(key, val.strs, indices) @@ -604,7 +640,11 @@ function split_kw(key, val::SeriesAnnotations, indices) end function groupedvec2mat(x_ind, x, y::AbstractArray, groupby, def_val = y[1]) - y_mat = Array{promote_type(eltype(y), typeof(def_val))}(undef, length(keys(x_ind)), length(groupby.groupLabels)) + y_mat = Array{promote_type(eltype(y), typeof(def_val))}( + undef, + length(keys(x_ind)), + length(groupby.groupLabels), + ) fill!(y_mat, def_val) for i in eachindex(groupby.groupLabels) xi = x[groupby.groupIds[i]] @@ -614,7 +654,8 @@ function groupedvec2mat(x_ind, x, y::AbstractArray, groupby, def_val = y[1]) return y_mat end -groupedvec2mat(x_ind, x, y::Tuple, groupby) = Tuple(groupedvec2mat(x_ind, x, v, groupby) for v in y) +groupedvec2mat(x_ind, x, y::Tuple, groupby) = + Tuple(groupedvec2mat(x_ind, x, v, groupby) for v in y) group_as_matrix(t) = false @@ -622,11 +663,11 @@ group_as_matrix(t) = false @recipe function f(groupby::GroupBy, args...) lengthGroup = maximum(union(groupby.groupIds...)) if !(group_as_matrix(args[1])) - for (i,glab) in enumerate(groupby.groupLabels) + for (i, glab) in enumerate(groupby.groupLabels) @series begin - label --> string(glab) + label --> string(glab) idxfilter --> groupby.groupIds[i] - for (key,val) in plotattributes + for (key, val) in plotattributes if splittable_kw(key, val, lengthGroup) :($key) := split_kw(key, val, groupby.groupIds[i]) end @@ -648,12 +689,15 @@ group_as_matrix(t) = false end x_u = unique(sort(x)) x_ind = Dict(zip(x_u, eachindex(x_u))) - for (key,val) in plotattributes + for (key, val) in plotattributes if splittable_kw(key, val, lengthGroup) :($key) := groupedvec2mat(x_ind, x, val, groupby) end end label --> reshape(groupby.groupLabels, 1, :) - typeof(g)((x_u, (groupedvec2mat(x_ind, x, arg, groupby, NaN) for arg in last_args)...)) + typeof(g)(( + x_u, + (groupedvec2mat(x_ind, x, arg, groupby, NaN) for arg in last_args)..., + )) end end diff --git a/src/utils.jl b/src/utils.jl index 7d274961..42f905c6 100644 --- a/src/utils.jl +++ b/src/utils.jl @@ -838,7 +838,7 @@ end function attr!(series::Series; kw...) plotattributes = KW(kw) - preprocessArgs!(plotattributes) + preprocess_attributes!(plotattributes) for (k,v) in plotattributes if haskey(_series_defaults, k) series[k] = v @@ -852,7 +852,7 @@ end function attr!(sp::Subplot; kw...) plotattributes = KW(kw) - preprocessArgs!(plotattributes) + preprocess_attributes!(plotattributes) for (k,v) in plotattributes if haskey(_subplot_defaults, k) sp[k] = v From f73b2819962ba78d9b2bff7eb3b9f669ce4da1d0 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Sat, 4 Apr 2020 17:30:04 +0200 Subject: [PATCH 02/17] extract the recipe pipeline into separate submodule --- src/Plots.jl | 18 + src/RecipePipeline/RecipePipeline.jl | 97 +++++ src/RecipePipeline/api.jl | 142 +++++++ src/RecipePipeline/group.jl | 122 ++++++ src/RecipePipeline/plot_recipe.jl | 46 +++ src/RecipePipeline/series.jl | 170 ++++++++ src/RecipePipeline/series_recipe.jl | 62 +++ src/RecipePipeline/type_recipe.jl | 94 +++++ src/RecipePipeline/user_recipe.jl | 330 +++++++++++++++ src/RecipePipeline/utils.jl | 220 ++++++++++ src/args.jl | 67 +-- src/axes.jl | 54 +-- src/backends/hdf5.jl | 18 +- src/components.jl | 50 +-- src/pipeline.jl | 274 ++++--------- src/plot.jl | 82 +--- src/recipes.jl | 2 + src/series.jl | 593 --------------------------- src/subplots.jl | 2 +- src/types.jl | 65 +-- src/utils.jl | 5 +- 21 files changed, 1425 insertions(+), 1088 deletions(-) create mode 100644 src/RecipePipeline/RecipePipeline.jl create mode 100644 src/RecipePipeline/api.jl create mode 100644 src/RecipePipeline/group.jl create mode 100644 src/RecipePipeline/plot_recipe.jl create mode 100644 src/RecipePipeline/series.jl create mode 100644 src/RecipePipeline/series_recipe.jl create mode 100644 src/RecipePipeline/type_recipe.jl create mode 100644 src/RecipePipeline/user_recipe.jl create mode 100644 src/RecipePipeline/utils.jl diff --git a/src/Plots.jl b/src/Plots.jl index 494d1da9..bf1571b7 100644 --- a/src/Plots.jl +++ b/src/Plots.jl @@ -167,6 +167,24 @@ using .PlotMeasures import .PlotMeasures: Length, AbsoluteLength, Measure, width, height # --------------------------------------------------------- +include("RecipePipeline/RecipePipeline.jl") +import .RecipePipeline +import .RecipePipeline: SliceIt, + DefaultsDict, + Formatted, + AbstractSurface, + Surface, + Volume, + is3d, + is_surface, + needs_3d_axes, + group_as_matrix, + reset_kw!, + pop_kw!, + scale_func, + inverse_scale_func, + unzip + include("types.jl") include("utils.jl") include("components.jl") diff --git a/src/RecipePipeline/RecipePipeline.jl b/src/RecipePipeline/RecipePipeline.jl new file mode 100644 index 00000000..03cc24e6 --- /dev/null +++ b/src/RecipePipeline/RecipePipeline.jl @@ -0,0 +1,97 @@ +module RecipePipeline + +import RecipesBase +import RecipesBase: @recipe, @series, RecipeData, is_explicit +import PlotUtils # tryrange and adapted_grid + +export recipe_pipeline! +# Plots relies on these: +export SliceIt, + DefaultsDict, + Formatted, + AbstractSurface, + Surface, + Volume, + is3d, + is_surface, + needs_3d_axes, + group_as_matrix, + reset_kw!, + pop_kw!, + scale_func, + inverse_scale_func, + unzip +# API +export warn_on_recipe_aliases, + splittable_attribute, + split_attribute, + process_userrecipe!, + get_axis_limits, + is_axis_attribute, + type_alias, + plot_setup!, + slice_series_attributes! + +include("api.jl") +include("utils.jl") +include("series.jl") +include("group.jl") +include("user_recipe.jl") +include("type_recipe.jl") +include("plot_recipe.jl") +include("series_recipe.jl") + + +""" + recipe_pipeline!(plt, plotattributes, args) + +Recursively apply user recipes, type recipes, plot recipes and series recipes to build a +list of `Dict`s, each corresponding to a series. At the beginning `plotattributes` +contains only the keyword arguments passed in by the user. Add all series to the plot +bject `plt` and return it. +""" +function recipe_pipeline!(plt, plotattributes, args) + plotattributes[:plot_object] = plt + + # -------------------------------- + # "USER RECIPES" + # -------------------------------- + + # process user and type recipes + kw_list = _process_userrecipes!(plt, plotattributes, args) + + # -------------------------------- + # "PLOT RECIPES" + # -------------------------------- + + # The "Plot recipe" acts like a series type, and is processed before the plot layout + # is created, which allows for setting layouts and other plot-wide attributes. + # We get inputs which have been fully processed by "user recipes" and "type recipes", + # so we can expect standard vectors, surfaces, etc. No defaults have been set yet. + + kw_list = _process_plotrecipes!(plt, kw_list) + + # -------------------------------- + # Plot/Subplot/Layout setup + # -------------------------------- + + plot_setup!(plt, plotattributes, kw_list) + + # At this point, `kw_list` is fully decomposed into individual series... one KW per + # series. The next step is to recursively apply series recipes until the backend + # supports that series type. + + # -------------------------------- + # "SERIES RECIPES" + # -------------------------------- + + _process_seriesrecipes!(plt, kw_list) + + # -------------------------------- + # Return processed plot object + # -------------------------------- + + return plt +end + +end diff --git a/src/RecipePipeline/api.jl b/src/RecipePipeline/api.jl new file mode 100644 index 00000000..feb9350a --- /dev/null +++ b/src/RecipePipeline/api.jl @@ -0,0 +1,142 @@ +## Warnings + +""" + warn_on_recipe_aliases!(plt, plotattributes, recipe_type, args...) + +Warn if an alias is dedected in `plotattributes` after a recipe of type `recipe_type` is +applied to 'args'. `recipe_type` is either `:user`, `:type`, `:plot` or `:series`. +""" +function warn_on_recipe_aliases!(plt, plotattributes, recipe_type, args...) end + + +## Grouping + +""" + splittable_attribute(plt, key, val, len) + +Returns `true` if the attribute `key` with the value `val` can be split into groups with +group provided as a vector of length `len`, `false` otherwise. +""" +splittable_attribute(plt, key, val, len) = false +splittable_attribute(plt, key, val::AbstractArray, len) = + !(key in (:group, :color_palette)) && length(axes(val, 1)) == len +splittable_attribute(plt, key, val::Tuple, n) = all(splittable_attribute.(key, val, len)) + + +""" + split_attribute(plt, key, val, indices) + +Select the proper indices from `val` for attribute `key`. +""" +split_attribute(plt, key, val::AbstractArray, indices) = + val[indices, fill(Colon(), ndims(val) - 1)...] +split_attribute(plt, key, val::Tuple, indices) = + Tuple(split_attribute(key, v, indices) for v in val) + + +## Preprocessing attributes + +""" + preprocess_attributes!(plt, plotattributes) + +Any plotting package specific preprocessing of user or recipe input happens here. +For example, Plots replaces aliases and expands magic arguments. +""" +function preprocess_attributes!(plt, plotattributes) end + +# TODO: should the Plots version be defined as fallback in RecipePipeline? +""" + is_subplot_attribute(plt, attr) + +Returns `true` if `attr` is a subplot attribute, otherwise `false`. +""" +is_subplot_attribute(plt, attr) = false + +# TODO: should the Plots version be defined as fallback in RecipePipeline? +""" + is_axis_attribute(plt, attr) + +Returns `true` if `attr` is an axis attribute, i.e. it applies to `xattr`, `yattr` and +`zattr`, otherwise `false`. +""" +is_axis_attribute(plt, attr) = false + + +## User recipes + +""" + process_userrecipe!(plt, attributes_list, attributes) + +Do plotting package specific post-processing and add series attributes to attributes_list. +For example, Plots increases the number of series in `plt`, sets `:series_plotindex` in +attributes and possible adds new series attributes for errorbars or smooth. +""" +function process_userrecipe!(plt, attributes_list, attributes) + push!(attributes_list, attributes) +end + +""" + get_axis_limits(plt, letter) + +Get the limits for the axis specified by `letter` (`:x`, `:y` or `:z`) in `plt`. If it +errors, `tryrange` from PlotUtils is used. +""" +get_axis_limits(plt, letter) = ErrorException("Axis limits not defined.") + + +## Plot recipes + +""" + type_alias(plt, st) + +Return the seriestype alias for `st`. +""" +type_alias(plt, st) = st + + +## Plot setup + +""" + plot_setup!(plt, plotattributes, kw_list) + +Setup plot, subplots and layouts. +For example, Plots creates the backend figure, initializes subplots, expands extrema and +links subplot axes. +""" +function plot_setup!(plt, plotattributes, kw_list) end + + +## Series recipes + +""" + slice_series_attributes!(plt, kw_list, kw) + +For attributes given as vector with one element per series, only select the value for +current series. +""" +function slice_series_attributes!(plt, kw_list, kw) end + + +""" + series_defaults(plt) + +Returns a `Dict` storing the defaults for series attributes. +""" +series_defaults(plt) = Dict{Symbol, Any}() + +# TODO: Add a more sensible fallback including e.g. path, scatter, ... +""" + is_seriestype_supported(plt, st) + +Check if the plotting package natively supports the seriestype `st`. +""" +is_seriestype_supported(plt, st) = false + +""" + add_series!(plt, kw) + +Adds the series defined by `kw` to the plot object. +For example Plots updates the current subplot arguments, expands extrema and pushes the +the series to the series_list of `plt`. +""" +function add_series!(plt, kw) end diff --git a/src/RecipePipeline/group.jl b/src/RecipePipeline/group.jl new file mode 100644 index 00000000..ca9d46c5 --- /dev/null +++ b/src/RecipePipeline/group.jl @@ -0,0 +1,122 @@ +"A special type that will break up incoming data into groups, and allow for easier creation of grouped plots" +mutable struct GroupBy + group_labels::Vector # length == numGroups + group_indices::Vector{Vector{Int}} # list of indices for each group +end + +# this is when given a vector-type of values to group by +function _extract_group_attributes(v::AVec, args...; legend_entry = string) + group_labels = sort(collect(unique(v))) + n = length(group_labels) + if n > 100 + @warn("You created n=$n groups... Is that intended?") + end + group_indices = Vector{Int}[filter(i -> v[i] == glab, eachindex(v)) for glab in group_labels] + GroupBy(map(legend_entry, group_labels), group_indices) +end + +legend_entry_from_tuple(ns::Tuple) = join(ns, ' ') + +# this is when given a tuple of vectors of values to group by +function _extract_group_attributes(vs::Tuple, args...) + isempty(vs) && return GroupBy([""], [axes(args[1],1)]) + v = map(tuple, vs...) + _extract_group_attributes(v, args...; legend_entry = legend_entry_from_tuple) +end + +# allow passing NamedTuples for a named legend entry +legend_entry_from_tuple(ns::NamedTuple) = + join(["$k = $v" for (k, v) in pairs(ns)], ", ") + +function _extract_group_attributes(vs::NamedTuple, args...) + isempty(vs) && return GroupBy([""], [axes(args[1],1)]) + v = map(NamedTuple{keys(vs)}∘tuple, values(vs)...) + _extract_group_attributes(v, args...; legend_entry = legend_entry_from_tuple) +end + +# expecting a mapping of "group label" to "group indices" +function _extract_group_attributes(idxmap::Dict{T,V}, args...) where {T, V<:AVec{Int}} + group_labels = sortedkeys(idxmap) + group_indices = Vector{Int}[collect(idxmap[k]) for k in group_labels] + GroupBy(group_labels, group_indices) +end + +filter_data(v::AVec, idxfilter::AVec{Int}) = v[idxfilter] +filter_data(v, idxfilter) = v + +function filter_data!(plotattributes::AKW, idxfilter) + for s in (:x, :y, :z) + plotattributes[s] = filter_data(get(plotattributes, s, nothing), idxfilter) + end +end + +function _filter_input_data!(plotattributes::AKW) + idxfilter = pop!(plotattributes, :idxfilter, nothing) + if idxfilter !== nothing + filter_data!(plotattributes, idxfilter) + end +end + +function groupedvec2mat(x_ind, x, y::AbstractArray, groupby, def_val = y[1]) + y_mat = Array{promote_type(eltype(y), typeof(def_val))}( + undef, + length(keys(x_ind)), + length(groupby.group_labels), + ) + fill!(y_mat, def_val) + for i in eachindex(groupby.group_labels) + xi = x[groupby.group_indices[i]] + yi = y[groupby.group_indices[i]] + y_mat[getindex.(Ref(x_ind), xi), i] = yi + end + return y_mat +end + +groupedvec2mat(x_ind, x, y::Tuple, groupby) = + Tuple(groupedvec2mat(x_ind, x, v, groupby) for v in y) + +group_as_matrix(t) = false + +# split the group into 1 series per group, and set the label and idxfilter for each +@recipe function f(groupby::GroupBy, args...) + plt = plotattributes[:plot_object] + group_length = maximum(union(groupby.group_indices...)) + if !(group_as_matrix(args[1])) + for (i, glab) in enumerate(groupby.group_labels) + @series begin + label --> string(glab) + idxfilter --> groupby.group_indices[i] + for (key, val) in plotattributes + if splittable_attribute(plt, key, val, group_length) + :($key) := split_attribute(plt, key, val, groupby.group_indices[i]) + end + end + args + end + end + else + g = args[1] + if length(g.args) == 1 + x = zeros(Int, group_length) + for indexes in groupby.group_indices + x[indexes] = eachindex(indexes) + end + last_args = g.args + else + x = g.args[1] + last_args = g.args[2:end] + end + x_u = unique(sort(x)) + x_ind = Dict(zip(x_u, eachindex(x_u))) + for (key, val) in plotattributes + if splittable_kw(key, val, group_length) + :($key) := groupedvec2mat(x_ind, x, val, groupby) + end + end + label --> reshape(groupby.group_labels, 1, :) + typeof(g)(( + x_u, + (groupedvec2mat(x_ind, x, arg, groupby, NaN) for arg in last_args)..., + )) + end +end diff --git a/src/RecipePipeline/plot_recipe.jl b/src/RecipePipeline/plot_recipe.jl new file mode 100644 index 00000000..6b7e05c3 --- /dev/null +++ b/src/RecipePipeline/plot_recipe.jl @@ -0,0 +1,46 @@ +""" + _process_plotrecipes!(plt, kw_list) + +Grab the first in line to be processed and pass it through `apply_recipe` to generate a +list of `RecipeData` objects. +If we applied a "plot recipe" without error, then add the returned datalist's KWs, +otherwise we just add the original KW. +""" +function _process_plotrecipes!(plt, kw_list) + still_to_process = kw_list + kw_list = KW[] + while !isempty(still_to_process) + next_kw = popfirst!(still_to_process) + _process_plotrecipe(plt, next_kw, kw_list, still_to_process) + end + return kw_list +end + + +function _process_plotrecipe(plt, kw, kw_list, still_to_process) + if !isa(get(kw, :seriestype, nothing), Symbol) + # seriestype was never set, or it's not a Symbol, so it can't be a plot recipe + push!(kw_list, kw) + return + end + try + st = kw[:seriestype] + st = kw[:seriestype] = type_alias(plt, st) + datalist = RecipesBase.apply_recipe(kw, Val{st}, plt) + warn_on_recipe_aliases!(plt, datalist, :plot, st) + for data in datalist + preprocess_attributes!(plt, data.plotattributes) + if data.plotattributes[:seriestype] == st + error("Plot recipe $st returned the same seriestype: $(data.plotattributes)") + end + push!(still_to_process, data.plotattributes) + end + catch err + if isa(err, MethodError) + push!(kw_list, kw) + else + rethrow() + end + end + return +end diff --git a/src/RecipePipeline/series.jl b/src/RecipePipeline/series.jl new file mode 100644 index 00000000..e967fa4c --- /dev/null +++ b/src/RecipePipeline/series.jl @@ -0,0 +1,170 @@ +const FuncOrFuncs{F} = Union{F, Vector{F}, Matrix{F}} +const MaybeNumber = Union{Number, Missing} +const MaybeString = Union{AbstractString, Missing} +const DataPoint = Union{MaybeNumber, MaybeString} + +_prepare_series_data(x) = error("Cannot convert $(typeof(x)) to series data for plotting") +_prepare_series_data(::Nothing) = nothing +_prepare_series_data(t::Tuple{T, T}) where {T <: Number} = t +_prepare_series_data(f::Function) = f +_prepare_series_data(ar::AbstractRange{<:Number}) = ar +function _prepare_series_data(a::AbstractArray{<:MaybeNumber}) + f = isimmutable(a) ? replace : replace! + a = f(x -> ismissing(x) || isinf(x) ? NaN : x, map(float, a)) +end +_prepare_series_data(a::AbstractArray{<:Missing}) = fill(NaN, axes(a)) +_prepare_series_data(a::AbstractArray{<:MaybeString}) = + replace(x -> ismissing(x) ? "" : x, a) +_prepare_series_data(s::Surface{<:AMat{<:MaybeNumber}}) = + Surface(_prepare_series_data(s.surf)) +_prepare_series_data(s::Surface) = s # non-numeric Surface, such as an image +_prepare_series_data(v::Volume) = + Volume(_prepare_series_data(v.v), v.x_extents, v.y_extents, v.z_extents) + +# default: assume x represents a single series +_series_data_vector(x, plotattributes) = [_prepare_series_data(x)] + +# fixed number of blank series +_series_data_vector(n::Integer, plotattributes) = [zeros(0) for i in 1:n] + +# vector of data points is a single series +_series_data_vector(v::AVec{<:DataPoint}, plotattributes) = [_prepare_series_data(v)] + +# list of things (maybe other vectors, functions, or something else) +function _series_data_vector(v::AVec, plotattributes) + if all(x -> x isa MaybeNumber, v) + _series_data_vector(Vector{MaybeNumber}(v), plotattributes) + elseif all(x -> x isa MaybeString, v) + _series_data_vector(Vector{MaybeString}(v), plotattributes) + else + vcat((_series_data_vector(vi, plotattributes) for vi in v)...) + end +end + +# Matrix is split into columns +function _series_data_vector(v::AMat{<:DataPoint}, plotattributes) + if is3d(plotattributes) + [_prepare_series_data(Surface(v))] + else + [_prepare_series_data(v[:, i]) for i in axes(v, 2)] + end +end + +# -------------------------------------------------------------------- +# Fillranges & ribbons + + +_process_fillrange(range::Number, plotattributes) = [range] +_process_fillrange(range, plotattributes) = _series_data_vector(range, plotattributes) + +_process_ribbon(ribbon::Number, plotattributes) = [ribbon] +_process_ribbon(ribbon, plotattributes) = _series_data_vector(ribbon, plotattributes) +# ribbon as a tuple: (lower_ribbons, upper_ribbons) +_process_ribbon(ribbon::Tuple{S, T}, plotattributes) where {S, T} = collect(zip( + _series_data_vector(ribbon[1], plotattributes), + _series_data_vector(ribbon[2], plotattributes), +)) + + +# -------------------------------------------------------------------- + +_compute_x(x::Nothing, y::Nothing, z) = axes(z, 1) +_compute_x(x::Nothing, y, z) = axes(y, 1) +_compute_x(x::Function, y, z) = map(x, y) +_compute_x(x, y, z) = x + +_compute_y(x::Nothing, y::Nothing, z) = axes(z, 2) +_compute_y(x, y::Function, z) = map(y, x) +_compute_y(x, y, z) = y + +_compute_z(x, y, z::Function) = map(z, x, y) +_compute_z(x, y, z::AbstractMatrix) = Surface(z) +_compute_z(x, y, z::Nothing) = nothing +_compute_z(x, y, z) = z + +_nobigs(v::AVec{BigFloat}) = map(Float64, v) +_nobigs(v::AVec{BigInt}) = map(Int64, v) +_nobigs(v) = v + +@noinline function _compute_xyz(x, y, z) + x = _compute_x(x, y, z) + y = _compute_y(x, y, z) + z = _compute_z(x, y, z) + _nobigs(x), _nobigs(y), _nobigs(z) +end + +# not allowed +_compute_xyz(x::Nothing, y::FuncOrFuncs{F}, z) where {F <: Function} = + error("If you want to plot the function `$y`, you need to define the x values!") +_compute_xyz(x::Nothing, y::Nothing, z::FuncOrFuncs{F}) where {F <: Function} = + error("If you want to plot the function `$z`, you need to define x and y values!") +_compute_xyz(x::Nothing, y::Nothing, z::Nothing) = error("x/y/z are all nothing!") + +# -------------------------------------------------------------------- + + +# we are going to build recipes to do the processing and splitting of the args + +# -------------------------------------------------------------------- +# The catch-all SliceIt recipe +# -------------------------------------------------------------------- + +# ensure we dispatch to the slicer +struct SliceIt end + +# TODO: Should ribbon and fillrange be handled by the plotting package? + +# The `SliceIt` recipe finishes user and type recipe processing. +# It splits processed data into individual series data, stores in copied `plotattributes` +# for each series and returns no arguments. +@recipe function f(::Type{SliceIt}, x, y, z) + + # handle data with formatting attached + if typeof(x) <: Formatted + xformatter := x.formatter + x = x.data + end + if typeof(y) <: Formatted + yformatter := y.formatter + y = y.data + end + if typeof(z) <: Formatted + zformatter := z.formatter + z = z.data + end + + xs = _series_data_vector(x, plotattributes) + ys = _series_data_vector(y, plotattributes) + zs = _series_data_vector(z, plotattributes) + + fr = pop!(plotattributes, :fillrange, nothing) + fillranges = _process_fillrange(fr, plotattributes) + mf = length(fillranges) + + rib = pop!(plotattributes, :ribbon, nothing) + ribbons = _process_ribbon(rib, plotattributes) + mr = length(ribbons) + + mx = length(xs) + my = length(ys) + mz = length(zs) + if mx > 0 && my > 0 && mz > 0 + for i in 1:max(mx, my, mz) + # add a new series + di = copy(plotattributes) + xi, yi, zi = xs[mod1(i, mx)], ys[mod1(i, my)], zs[mod1(i, mz)] + di[:x], di[:y], di[:z] = _compute_xyz(xi, yi, zi) + + # handle fillrange + fr = fillranges[mod1(i, mf)] + di[:fillrange] = isa(fr, Function) ? map(fr, di[:x]) : fr + + # handle ribbons + rib = ribbons[mod1(i, mr)] + di[:ribbon] = isa(rib, Function) ? map(rib, di[:x]) : rib + + push!(series_list, RecipeData(di, ())) + end + end + nothing # don't add a series for the main block +end diff --git a/src/RecipePipeline/series_recipe.jl b/src/RecipePipeline/series_recipe.jl new file mode 100644 index 00000000..37bb6a4c --- /dev/null +++ b/src/RecipePipeline/series_recipe.jl @@ -0,0 +1,62 @@ +""" + _process_seriesrecipes!(plt, kw_list) + +Recursively apply series recipes until the backend supports the seriestype +""" +function _process_seriesrecipes!(plt, kw_list) + for kw in kw_list + # in series attributes given as vector with one element per series, + # select the value for current series + slice_series_attributes!(plt, kw_list, kw) + + series_attr = DefaultsDict(kw, series_defaults(plt)) + # now we have a fully specified series, with colors chosen. we must recursively + # handle series recipes, which dispatch on seriestype. If a backend does not + # natively support a seriestype, we check for a recipe that will convert that + # series type into one made up of lower-level components. + # For example, a histogram is just a bar plot with binned data, a bar plot is + # really a filled step plot, and a step plot is really just a path. So any backend + # that supports drawing a path will implicitly be able to support step, bar, and + # histogram plots (and any recipes that use those components). + _process_seriesrecipe(plt, series_attr) + end +end + +# this method recursively applies series recipes when the seriestype is not supported +# natively by the backend +function _process_seriesrecipe(plt, plotattributes) + # replace seriestype aliases + st = Symbol(plotattributes[:seriestype]) + st = plotattributes[:seriestype] = type_alias(plt, st) + + # shapes shouldn't have fillrange set + if plotattributes[:seriestype] == :shape + plotattributes[:fillrange] = nothing + end + + # if it's natively supported, finalize processing and pass along to the backend, + # otherwise recurse + if is_seriestype_supported(plt, st) + add_series!(plt, plotattributes) + else + # get a sub list of series for this seriestype + x, y, z = plotattributes[:x], plotattributes[:y], plotattributes[:z] + datalist = RecipesBase.apply_recipe(plotattributes, Val{st}, x, y, z) + warn_on_recipe_aliases!(plt, datalist, :series, st) + + # assuming there was no error, recursively apply the series recipes + for data in datalist + if isa(data, RecipeData) + preprocess_attributes!(plt, data.plotattributes) + if data.plotattributes[:seriestype] == st + error("The seriestype didn't change in series recipe $st. This will cause a StackOverflow.") + end + _process_seriesrecipe(plt, data.plotattributes) + else + @warn("Unhandled recipe: $(data)") + break + end + end + end + nothing +end diff --git a/src/RecipePipeline/type_recipe.jl b/src/RecipePipeline/type_recipe.jl new file mode 100644 index 00000000..527fbae6 --- /dev/null +++ b/src/RecipePipeline/type_recipe.jl @@ -0,0 +1,94 @@ +# this is the default "type recipe"... just pass the object through +@recipe f(::Type{T}, v::T) where {T} = v + +# this should catch unhandled "series recipes" and error with a nice message +@recipe f(::Type{V}, x, y, z) where {V <: Val} = + error("The backend must not support the series type $V, and there isn't a series recipe defined.") + +""" + _apply_type_recipe(plotattributes, v::T, letter) + +Apply the type recipe with signature `(::Type{T}, ::T)`. +""" +function _apply_type_recipe(plotattributes, v, letter) + _preprocess_axis_args!(plotattributes, letter) + rdvec = RecipesBase.apply_recipe(plotattributes, typeof(v), v) + warn_on_recipe_aliases!(plotattributes[:plot_object], plotattributes, :type, typeof(v)) + _postprocess_axis_args!(plotattributes, letter) + return rdvec[1].args[1] +end + +# Handle type recipes when the recipe is defined on the elements. +# This sort of recipe should return a pair of functions... one to convert to number, +# and one to format tick values. +function _apply_type_recipe(plotattributes, v::AbstractArray, letter) + plt = plotattributes[:plot_object] + _preprocess_axis_args!(plotattributes, letter) + # First we try to apply an array type recipe. + w = RecipesBase.apply_recipe(plotattributes, typeof(v), v)[1].args[1] + warn_on_recipe_aliases!(plt, plotattributes, :type, typeof(v)) + # If the type did not change try it element-wise + if typeof(v) == typeof(w) + isempty(skipmissing(v)) && return Float64[] + x = first(skipmissing(v)) + args = RecipesBase.apply_recipe(plotattributes, typeof(x), x)[1].args + warn_on_recipe_aliases!(plt, plotattributes, :type, typeof(x)) + _postprocess_axis_args!(plotattributes, letter) + if length(args) == 2 && all(arg -> arg isa Function, args) + numfunc, formatter = args + return Formatted(map(numfunc, v), formatter) + else + return v + end + end + _postprocess_axis_args!(plotattributes, letter) + return w +end + +# special handling for Surface... need to properly unwrap and re-wrap +_apply_type_recipe(plotattributes, v::Surface{<:AMat{<:DataPoint}}) = v +function _apply_type_recipe(plotattributes, v::Surface) + ret = _apply_type_recipe(plotattributes, v.surf) + if typeof(ret) <: Formatted + Formatted(Surface(ret.data), ret.formatter) + else + Surface(ret.data) + end +end + +# don't do anything for datapoints or nothing +_apply_type_recipe(plotattributes, v::AbstractArray{<:DataPoint}, letter) = v +_apply_type_recipe(plotattributes, v::Nothing, letter) = v + +# axis args before type recipes should still be mapped to all axes +function _preprocess_axis_args!(plotattributes) + plt = plotattributes[:plot_object] + for (k, v) in plotattributes + if is_axis_attribute(plt, k) + pop!(plotattributes, k) + for l in (:x, :y, :z) + lk = Symbol(l, k) + haskey(plotattributes, lk) || (plotattributes[lk] = v) + end + end + end +end +function _preprocess_axis_args!(plotattributes, letter) + plotattributes[:letter] = letter + _preprocess_axis_args!(plotattributes) +end + +# axis args in type recipes should only be applied to the current axis +function _postprocess_axis_args!(plotattributes, letter) + plt = plotattributes[:plot_object] + pop!(plotattributes, :letter) + if letter in (:x, :y, :z) + for (k, v) in plotattributes + if is_axis_attribute(plt, k) + pop!(plotattributes, k) + lk = Symbol(letter, k) + haskey(plotattributes, lk) || (plotattributes[lk] = v) + end + end + end +end diff --git a/src/RecipePipeline/user_recipe.jl b/src/RecipePipeline/user_recipe.jl new file mode 100644 index 00000000..0023474f --- /dev/null +++ b/src/RecipePipeline/user_recipe.jl @@ -0,0 +1,330 @@ +""" + _process_userrecipes(plt, plotattributes, args) + +Wrap input arguments in a `RecipeData' vector and recursively apply user recipes and type +recipes on the first element. Prepend the returned `RecipeData` vector. If an element with +empy `args` is returned pop it from the vector, finish up, and it to vector of `Dict`s with +processed series. When all arguments are processed return the series `Dict`. +""" +function _process_userrecipes!(plt, plotattributes, args) + still_to_process = _recipedata_vector(plt, plotattributes, args) + + # for plotting recipes, swap out the args and update the parameter dictionary + # we are keeping a stack of series that still need to be processed. + # each pass through the loop, we pop one off and apply the recipe. + # the recipe will return a list a Series objects... the ones that are + # finished (no more args) get added to the kw_list, the ones that are not + # are placed on top of the stack and are then processed further. + kw_list = KW[] + while !isempty(still_to_process) + # grab the first in line to be processed and either add it to the kw_list or + # pass it through apply_recipe to generate a list of RecipeData objects + # (data + attributes) for further processing. + next_series = popfirst!(still_to_process) + # recipedata should be of type RecipeData. + # if it's not then the inputs must not have been fully processed by recipes + if !(typeof(next_series) <: RecipeData) + error("Inputs couldn't be processed... expected RecipeData but got: $next_series") + end + if isempty(next_series.args) + _finish_userrecipe!(plt, kw_list, next_series) + else + rd_list = + RecipesBase.apply_recipe(next_series.plotattributes, next_series.args...) + warn_on_recipe_aliases!(plt, rd_list, :user, next_series.args...) + prepend!(still_to_process, rd_list) + end + end + + # don't allow something else to handle it + plotattributes[:smooth] = false + kw_list +end + + +# TODO Move this to api.jl? + +function _recipedata_vector(plt, plotattributes, args) + still_to_process = RecipeData[] + # the grouping mechanism is a recipe on a GroupBy object + # we simply add the GroupBy object to the front of the args list to allow + # the recipe to be applied + if haskey(plotattributes, :group) + args = (_extract_group_attributes(plotattributes[:group], args...), args...) + end + + # if we were passed a vector/matrix of seriestypes and there's more than one row, + # we want to duplicate the inputs, once for each seriestype row. + if !isempty(args) + append!(still_to_process, _expand_seriestype_array(plotattributes, args)) + end + + # remove subplot and axis args from plotattributes... + # they will be passed through in the kw_list + if !isempty(args) + for (k, v) in plotattributes + if is_subplot_attribute(plt, k) || is_axis_attribute(plt, k) + reset_kw!(plotattributes, k) + end + end + end + + still_to_process +end + +function _expand_seriestype_array(plotattributes, args) + sts = get(plotattributes, :seriestype, :path) + if typeof(sts) <: AbstractArray + reset_kw!(plotattributes, :seriestype) + rd = Vector{RecipeData}(undef, size(sts, 1)) + for r in axes(sts, 1) + dc = copy(plotattributes) + dc[:seriestype] = sts[r:r, :] + rd[r] = RecipeData(dc, args) + end + rd + else + RecipeData[RecipeData(copy(plotattributes), args)] + end +end + + +function _finish_userrecipe!(plt, kw_list, recipedata) + # when the arg tuple is empty, that means there's nothing left to recursively + # process... finish up and add to the kw_list + kw = recipedata.plotattributes + preprocess_attributes!(plt, kw) + # if there was a grouping, filter the data here + _filter_input_data!(kw) + process_userrecipe!(plt, kw_list, kw) +end + + +# -------------------------------- +# Fallback user recipes +# -------------------------------- + +# These call `_apply_type_recipe` in type_recipe.jl and finally the `SliceIt` recipe in +# series.jl. + +# handle "type recipes" by converting inputs, and then either re-calling or slicing +@recipe function f(x, y, z) + wrap_surfaces!(plotattributes, x, y, z) + did_replace = false + newx = _apply_type_recipe(plotattributes, x, :x) + x === newx || (did_replace = true) + newy = _apply_type_recipe(plotattributes, y, :y) + y === newy || (did_replace = true) + newz = _apply_type_recipe(plotattributes, z, :z) + z === newz || (did_replace = true) + if did_replace + newx, newy, newz + else + SliceIt, x, y, z + end +end +@recipe function f(x, y) + wrap_surfaces!(plotattributes, x, y) + did_replace = false + newx = _apply_type_recipe(plotattributes, x, :x) + x === newx || (did_replace = true) + newy = _apply_type_recipe(plotattributes, y, :y) + y === newy || (did_replace = true) + if did_replace + newx, newy + else + SliceIt, x, y, nothing + end +end +@recipe function f(y) + wrap_surfaces!(plotattributes, y) + newy = _apply_type_recipe(plotattributes, y, :y) + if y !== newy + newy + else + SliceIt, nothing, y, nothing + end +end + +# if there's more than 3 inputs, it can't be passed directly to SliceIt +# so we'll apply_type_recipe to all of them +@recipe function f(v1, v2, v3, v4, vrest...) + did_replace = false + newargs = map( + v -> begin + newv = _apply_type_recipe(plotattributes, v, :unknown) + if newv !== v + did_replace = true + end + newv + end, + (v1, v2, v3, v4, vrest...), + ) + if !did_replace + error("Couldn't process recipe args: $(map(typeof, (v1, v2, v3, v4, vrest...)))") + end + newargs +end + + +# helper function to ensure relevant attributes are wrapped by Surface +function wrap_surfaces!(plotattributes, args...) end +wrap_surfaces!(plotattributes, x::AMat, y::AMat, z::AMat) = wrap_surfaces!(plotattributes) +wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::AMat) = wrap_surfaces!(plotattributes) +function wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::Surface) + wrap_surfaces!(plotattributes) +end +function wrap_surfaces!(plotattributes) + if haskey(plotattributes, :fill_z) + v = plotattributes[:fill_z] + if !isa(v, Surface) + plotattributes[:fill_z] = Surface(v) + end + end +end + + +# -------------------------------- +# Special Cases +# -------------------------------- + +# -------------------------------- +# 1 argument + +@recipe function f(n::Integer) + if is3d(plotattributes) + SliceIt, n, n, n + else + SliceIt, n, n, nothing + end +end + +# return a surface if this is a 3d plot, otherwise let it be sliced up +@recipe function f(mat::AMat) + if is3d(plotattributes) + n, m = axes(mat) + m, n, Surface(mat) + else + nothing, mat, nothing + end +end + +# if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface +@recipe function f(fmt::Formatted{<:AMat}) + if is3d(plotattributes) + mat = fmt.data + n, m = axes(mat) + m, n, Formatted(Surface(mat), fmt.formatter) + else + nothing, fmt, nothing + end +end + +# assume this is a Volume, so construct one +@recipe function f(vol::AbstractArray{<:MaybeNumber, 3}, args...) + seriestype := :volume + SliceIt, nothing, Volume(vol, args...), nothing +end + +# Dicts: each entry is a data point (x,y)=(key,value) +@recipe f(d::AbstractDict) = collect(keys(d)), collect(values(d)) + +# function without range... use the current range of the x-axis +@recipe function f(f::FuncOrFuncs{F}) where {F <: Function} + plt = plotattributes[:plot_object] + xmin, xmax = if haskey(plotattributes, :xlims) + plotattributes[:xlims] + else + try + get_axis_limits(plt, :x) + catch + xinv = inverse_scale_func(get(plotattributes, :xscale, :identity)) + xm = PlotUtils.tryrange(f, xinv.([-5, -1, 0, 0.01])) + xm, PlotUtils.tryrange(f, filter(x -> x > xm, xinv.([5, 1, 0.99, 0, -0.01]))) + end + end + f, xmin, xmax +end + + +# -------------------------------- +# 2 arguments + +# if functions come first, just swap the order (not to be confused with parametric +# functions... as there would be more than one function passed in) +@recipe function f(f::FuncOrFuncs{F}, x) where {F <: Function} + F2 = typeof(x) + @assert !(F2 <: Function || (F2 <: AbstractArray && F2.parameters[1] <: Function)) + # otherwise we'd hit infinite recursion here + x, f +end + + +# -------------------------------- +# 3 arguments + +# surface-like... function +@recipe function f(x::AVec, y::AVec, zf::Function) + x, y, Surface(zf, x, y) # TODO: replace with SurfaceFunction when supported +end + +# surface-like... matrix grid +@recipe function f(x::AVec, y::AVec, z::AMat) + if !is_surface(plotattributes) + plotattributes[:seriestype] = :contour + end + x, y, Surface(z) +end + +# parametric functions +# special handling... xmin/xmax with parametric function(s) +@recipe function f(f::Function, xmin::Number, xmax::Number) + xscale, yscale = [get(plotattributes, sym, :identity) for sym in (:xscale, :yscale)] + _scaled_adapted_grid(f, xscale, yscale, xmin, xmax) +end +@recipe function f(fs::AbstractArray{F}, xmin::Number, xmax::Number) where {F <: Function} + xscale, yscale = [get(plotattributes, sym, :identity) for sym in (:xscale, :yscale)] + unzip(_scaled_adapted_grid.(fs, xscale, yscale, xmin, xmax)) +end +@recipe f( + fx::FuncOrFuncs{F}, + fy::FuncOrFuncs{G}, + u::AVec, +) where {F <: Function, G <: Function} = _map_funcs(fx, u), _map_funcs(fy, u) +@recipe f( + fx::FuncOrFuncs{F}, + fy::FuncOrFuncs{G}, + umin::Number, + umax::Number, + n = 200, +) where {F <: Function, G <: Function} = fx, fy, range(umin, stop = umax, length = n) + +function _scaled_adapted_grid(f, xscale, yscale, xmin, xmax) + (xf, xinv), (yf, yinv) = ((scale_func(s), inverse_scale_func(s)) for s in (xscale, yscale)) + xs, ys = PlotUtils.adapted_grid(yf ∘ f ∘ xinv, xf.((xmin, xmax))) + xinv.(xs), yinv.(ys) +end + +# special handling... 3D parametric function(s) +@recipe function f( + fx::FuncOrFuncs{F}, + fy::FuncOrFuncs{G}, + fz::FuncOrFuncs{H}, + u::AVec, +) where {F <: Function, G <: Function, H <: Function} + _map_funcs(fx, u), _map_funcs(fy, u), _map_funcs(fz, u) +end +@recipe function f( + fx::FuncOrFuncs{F}, + fy::FuncOrFuncs{G}, + fz::FuncOrFuncs{H}, + umin::Number, + umax::Number, + numPoints = 200, +) where {F <: Function, G <: Function, H <: Function} + fx, fy, fz, range(umin, stop = umax, length = numPoints) +end + +# list of tuples +@recipe f(v::AVec{<:Tuple}) = unzip(v) +@recipe f(tup::Tuple) = [tup] diff --git a/src/RecipePipeline/utils.jl b/src/RecipePipeline/utils.jl new file mode 100644 index 00000000..54862d47 --- /dev/null +++ b/src/RecipePipeline/utils.jl @@ -0,0 +1,220 @@ +const AVec = AbstractVector +const AMat = AbstractMatrix +const KW = Dict{Symbol, Any} +const AKW = AbstractDict{Symbol, Any} + +# -------------------------------- +# DefaultsDict +# -------------------------------- + +struct DefaultsDict <: AbstractDict{Symbol, Any} + explicit::KW + defaults::KW +end + +function Base.getindex(dd::DefaultsDict, k) + return haskey(dd.explicit, k) ? dd.explicit[k] : dd.defaults[k] +end +Base.haskey(dd::DefaultsDict, k) = haskey(dd.explicit, k) || haskey(dd.defaults, k) +Base.get(dd::DefaultsDict, k, default) = haskey(dd, k) ? dd[k] : default +function Base.get!(dd::DefaultsDict, k, default) + v = if haskey(dd, k) + dd[k] + else + dd.defaults[k] = default + end + return v +end +function Base.delete!(dd::DefaultsDict, k) + haskey(dd.explicit, k) && delete!(dd.explicit, k) + haskey(dd.defaults, k) && delete!(dd.defaults, k) +end +Base.length(dd::DefaultsDict) = length(union(keys(dd.explicit), keys(dd.defaults))) +function Base.iterate(dd::DefaultsDict) + exp_keys = keys(dd.explicit) + def_keys = setdiff(keys(dd.defaults), exp_keys) + key_list = collect(Iterators.flatten((exp_keys, def_keys))) + iterate(dd, (key_list, 1)) +end +function Base.iterate(dd::DefaultsDict, (key_list, i)) + i > length(key_list) && return nothing + k = key_list[i] + (k => dd[k], (key_list, i + 1)) +end + +Base.copy(dd::DefaultsDict) = DefaultsDict(copy(dd.explicit), dd.defaults) + +RecipesBase.is_explicit(dd::DefaultsDict, k) = haskey(dd.explicit, k) +isdefault(dd::DefaultsDict, k) = !is_explicit(dd, k) && haskey(dd.defaults, k) + +Base.setindex!(dd::DefaultsDict, v, k) = dd.explicit[k] = v + +# Reset to default value and return dict +reset_kw!(dd::DefaultsDict, k) = is_explicit(dd, k) ? delete!(dd.explicit, k) : dd +# Reset to default value and return old value +pop_kw!(dd::DefaultsDict, k) = is_explicit(dd, k) ? pop!(dd.explicit, k) : dd.defaults[k] +pop_kw!(dd::DefaultsDict, k, default) = + is_explicit(dd, k) ? pop!(dd.explicit, k) : get(dd.defaults, k, default) +# Fallbacks for dicts without defaults +reset_kw!(d::AKW, k) = delete!(d, k) +pop_kw!(d::AKW, k) = pop!(d, k) +pop_kw!(d::AKW, k, default) = pop!(d, k, default) + + +# -------------------------------- +# 3D types +# -------------------------------- + +abstract type AbstractSurface end + +"represents a contour or surface mesh" +struct Surface{M <: AMat} <: AbstractSurface + surf::M +end + +Surface(f::Function, x, y) = Surface(Float64[f(xi, yi) for yi in y, xi in x]) + +Base.Array(surf::Surface) = surf.surf + +for f in (:length, :size, :axes) + @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...) +end +Base.copy(surf::Surface) = Surface(copy(surf.surf)) +Base.eltype(surf::Surface{T}) where {T} = eltype(T) + + +struct Volume{T} + v::Array{T, 3} + x_extents::Tuple{T, T} + y_extents::Tuple{T, T} + z_extents::Tuple{T, T} +end + +default_extents(::Type{T}) where {T} = (zero(T), one(T)) + +function Volume( + v::Array{T, 3}, + x_extents = default_extents(T), + y_extents = default_extents(T), + z_extents = default_extents(T), +) where {T} + Volume(v, x_extents, y_extents, z_extents) +end + +Base.Array(vol::Volume) = vol.v +for f in (:length, :size) + @eval Base.$f(vol::Volume, args...) = $f(vol.v, args...) +end +Base.copy(vol::Volume{T}) where {T} = + Volume{T}(copy(vol.v), vol.x_extents, vol.y_extents, vol.z_extents) +Base.eltype(vol::Volume{T}) where {T} = T + + +# -------------------------------- +# Formatting +# -------------------------------- + +"Represents data values with formatting that should apply to the tick labels." +struct Formatted{T} + data::T + formatter::Function +end + +# ------------------------------- +# 3D seriestypes +# ------------------------------- + +# TODO: Move to RecipesBase? +""" + is3d(::Type{Val{:myseriestype}}) + +Returns `true` if `myseriestype` represents a 3D series, `false` otherwise. +""" +is3d(st) = false +for st in ( + :contour, + :contourf, + :contour3d, + :heatmap, + :image, + :path3d, + :scatter3d, + :surface, + :volume, + :wireframe, +) + @eval is3d(::Type{Val{Symbol($(string(st)))}}) = true +end +is3d(st::Symbol) = is3d(Val{st}) +is3d(plt, stv::AbstractArray) = all(st -> is3d(plt, st), stv) +is3d(plotattributes::AbstractDict) = is3d(get(plotattributes, :seriestype, :path)) + + +""" + is_surface(::Type{Val{:myseriestype}}) + +Returns `true` if `myseriestype` represents a surface series, `false` otherwise. +""" +is_surface(st) = false +for st in (:contour, :contourf, :contour3d, :image, :heatmap, :surface, :wireframe) + @eval is_surface(::Type{Val{Symbol($(string(st)))}}) = true +end +is_surface(st::Symbol) = is_surface(Val{st}) +is_surface(plt, stv::AbstractArray) = all(st -> is_surface(plt, st), stv) +is_surface(plotattributes::AbstractDict) = + is_surface(get(plotattributes, :seriestype, :path)) + + +""" + needs_3d_axes(::Type{Val{:myseriestype}}) + +Returns `true` if `myseriestype` needs 3d axes, `false` otherwise. +""" +needs_3d_axes(st) = false +for st in ( + :contour3d, + :path3d, + :scatter3d, + :surface, + :volume, + :wireframe, +) + @eval needs_3d_axes(::Type{Val{Symbol($(string(st)))}}) = true +end +needs_3d_axes(st::Symbol) = needs_3d_axes(Val{st}) +needs_3d_axes(plt, stv::AbstractArray) = all(st -> needs_3d_axes(plt, st), stv) +needs_3d_axes(plotattributes::AbstractDict) = + needs_3d_axes(get(plotattributes, :seriestype, :path)) + + +# -------------------------------- +# Scales +# -------------------------------- + +const SCALE_FUNCTIONS = Dict{Symbol, Function}(:log10 => log10, :log2 => log2, :ln => log) +const INVERSE_SCALE_FUNCTIONS = + Dict{Symbol, Function}(:log10 => exp10, :log2 => exp2, :ln => exp) + +scale_func(scale::Symbol) = x -> get(SCALE_FUNCTIONS, scale, identity)(Float64(x)) +inverse_scale_func(scale::Symbol) = + x -> get(INVERSE_SCALE_FUNCTIONS, scale, identity)(Float64(x)) + + +# -------------------------------- +# Unzip +# -------------------------------- + +for i in 2:4 + @eval begin + unzip(v::AVec{<:Tuple{Vararg{T, $i} where T}}) = + $(Expr(:tuple, (:([t[$j] for t in v]) for j in 1:i)...)) + end +end + + +# -------------------------------- +# Map functions on vectors +# -------------------------------- + +_map_funcs(f::Function, u::AVec) = map(f, u) +_map_funcs(fs::AVec{F}, u::AVec) where {F <: Function} = [map(f, u) for f in fs] diff --git a/src/args.jl b/src/args.jl index 000ba22e..e303ed32 100644 --- a/src/args.jl +++ b/src/args.jl @@ -86,12 +86,9 @@ const _surface_like = [:contour, :contourf, :contour3d, :heatmap, :surface, :wir like_histogram(seriestype::Symbol) = seriestype in _histogram_like like_line(seriestype::Symbol) = seriestype in _line_like -like_surface(seriestype::Symbol) = seriestype in _surface_like +like_surface(seriestype::Symbol) = is_surface(seriestype) -is3d(seriestype::Symbol) = seriestype in _3dTypes is3d(series::Series) = is3d(series.plotattributes) -is3d(plotattributes::AKW) = trueOrAllTrue(is3d, Symbol(plotattributes[:seriestype])) - is3d(sp::Subplot) = string(sp.attr[:projection]) == "3d" ispolar(sp::Subplot) = string(sp.attr[:projection]) == "polar" ispolar(series::Series) = ispolar(series.plotattributes[:subplot]) @@ -1115,68 +1112,6 @@ function preprocess_attributes!(plotattributes::AKW) return end -# ----------------------------------------------------------------------------- - -"A special type that will break up incoming data into groups, and allow for easier creation of grouped plots" -mutable struct GroupBy - groupLabels::Vector # length == numGroups - groupIds::Vector{Vector{Int}} # list of indices for each group -end - - -# this is when given a vector-type of values to group by -function _extract_group_attributes(v::AVec, args...; legendEntry = string) - groupLabels = sort(collect(unique(v))) - n = length(groupLabels) - if n > 100 - @warn("You created n=$n groups... Is that intended?") - end - groupIds = Vector{Int}[filter(i -> v[i] == glab, eachindex(v)) for glab in groupLabels] - GroupBy(map(legendEntry, groupLabels), groupIds) -end - -legendEntryFromTuple(ns::Tuple) = join(ns, ' ') - -# this is when given a tuple of vectors of values to group by -function _extract_group_attributes(vs::Tuple, args...) - isempty(vs) && return GroupBy([""], [axes(args[1],1)]) - v = map(tuple, vs...) - _extract_group_attributes(v, args...; legendEntry = legendEntryFromTuple) -end - -# allow passing NamedTuples for a named legend entry -legendEntryFromTuple(ns::NamedTuple) = - join(["$k = $v" for (k, v) in pairs(ns)], ", ") - -function _extract_group_attributes(vs::NamedTuple, args...) - isempty(vs) && return GroupBy([""], [axes(args[1],1)]) - v = map(NamedTuple{keys(vs)}∘tuple, values(vs)...) - _extract_group_attributes(v, args...; legendEntry = legendEntryFromTuple) -end - -# expecting a mapping of "group label" to "group indices" -function _extract_group_attributes(idxmap::Dict{T,V}, args...) where {T, V<:AVec{Int}} - groupLabels = sortedkeys(idxmap) - groupIds = Vector{Int}[collect(idxmap[k]) for k in groupLabels] - GroupBy(groupLabels, groupIds) -end - -filter_data(v::AVec, idxfilter::AVec{Int}) = v[idxfilter] -filter_data(v, idxfilter) = v - -function filter_data!(plotattributes::AKW, idxfilter) - for s in (:x, :y, :z) - plotattributes[s] = filter_data(get(plotattributes, s, nothing), idxfilter) - end -end - -function _filter_input_data!(plotattributes::AKW) - idxfilter = pop!(plotattributes, :idxfilter, nothing) - if idxfilter !== nothing - filter_data!(plotattributes, idxfilter) - end -end - # ----------------------------------------------------------------------------- diff --git a/src/axes.jl b/src/axes.jl index 15e93b1f..4069b4e6 100644 --- a/src/axes.jl +++ b/src/axes.jl @@ -17,7 +17,7 @@ function Axis(sp::Subplot, letter::Symbol, args...; kw...) :show => true, # show or hide the axis? (useful for linked subplots) ) - attr = Attr(explicit, _axis_defaults_byletter[letter]) + attr = DefaultsDict(explicit, _axis_defaults_byletter[letter]) # update the defaults attr!(Axis([sp], attr), args...; kw...) @@ -117,33 +117,11 @@ Base.setindex!(axis::Axis, v, ks::Symbol...) = setindex!(axis.plotattributes, v, Base.haskey(axis::Axis, k::Symbol) = haskey(axis.plotattributes, k) ignorenan_extrema(axis::Axis) = (ex = axis[:extrema]; (ex.emin, ex.emax)) - -const _scale_funcs = Dict{Symbol,Function}( - :log10 => log10, - :log2 => log2, - :ln => log, -) -const _inv_scale_funcs = Dict{Symbol,Function}( - :log10 => exp10, - :log2 => exp2, - :ln => exp, -) - -# const _label_func = Dict{Symbol,Function}( -# :log10 => x -> "10^$x", -# :log2 => x -> "2^$x", -# :ln => x -> "e^$x", -# ) - const _label_func = Dict{Symbol,Function}( :log10 => x -> "10^$x", :log2 => x -> "2^$x", :ln => x -> "e^$x", ) - - -scalefunc(scale::Symbol) = x -> get(_scale_funcs, scale, identity)(Float64(x)) -invscalefunc(scale::Symbol) = x -> get(_inv_scale_funcs, scale, identity)(Float64(x)) labelfunc(scale::Symbol, backend::AbstractBackend) = get(_label_func, scale, string) function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing) @@ -151,7 +129,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing) # scale the limits scale = axis[:scale] - sf = scalefunc(scale) + sf = scale_func(scale) # If the axis input was a Date or DateTime use a special logic to find # "round" Date(Time)s as ticks @@ -196,11 +174,11 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing) # chosen ticks is not too much bigger than amin - amax: strict_span = false, ) - axis[:lims] = map(invscalefunc(scale), (viewmin, viewmax)) + axis[:lims] = map(inverse_scale_func(scale), (viewmin, viewmax)) else scaled_ticks = map(sf, (filter(t -> amin <= t <= amax, ticks))) end - unscaled_ticks = map(invscalefunc(scale), scaled_ticks) + unscaled_ticks = map(inverse_scale_func(scale), scaled_ticks) labels = if any(isfinite, unscaled_ticks) formatter = axis[:formatter] @@ -400,7 +378,7 @@ function expand_extrema!(sp::Subplot, plotattributes::AKW) if fr === nothing && plotattributes[:seriestype] == :bar fr = 0.0 end - if fr !== nothing && !all3D(plotattributes) + if fr !== nothing && !is3d(plotattributes) axis = sp.attr[vert ? :yaxis : :xaxis] if typeof(fr) <: Tuple for fri in fr @@ -445,7 +423,7 @@ end # push the limits out slightly function widen(lmin, lmax, scale = :identity) - f, invf = scalefunc(scale), invscalefunc(scale) + f, invf = scale_func(scale), inverse_scale_func(scale) span = f(lmax) - f(lmin) # eps = NaNMath.max(1e-16, min(1e-2span, 1e-10)) eps = NaNMath.max(1e-16, 0.03span) @@ -648,8 +626,8 @@ function axis_drawing_info(sp::Subplot) sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin, y2), (xmax, y2)) # top spine end if !(xaxis[:ticks] in (:none, nothing, false)) - f = scalefunc(yaxis[:scale]) - invf = invscalefunc(yaxis[:scale]) + f = scale_func(yaxis[:scale]) + invf = inverse_scale_func(yaxis[:scale]) tick_start, tick_stop = if sp[:framestyle] == :origin t = invf(f(0) + 0.012 * (f(ymax) - f(ymin))) (-t, t) @@ -702,8 +680,8 @@ function axis_drawing_info(sp::Subplot) sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (x2, ymin), (x2, ymax)) # right spine end if !(yaxis[:ticks] in (:none, nothing, false)) - f = scalefunc(xaxis[:scale]) - invf = invscalefunc(xaxis[:scale]) + f = scale_func(xaxis[:scale]) + invf = inverse_scale_func(xaxis[:scale]) tick_start, tick_stop = if sp[:framestyle] == :origin t = invf(f(0) + 0.012 * (f(xmax) - f(xmin))) (-t, t) @@ -794,8 +772,8 @@ function axis_drawing_info_3d(sp::Subplot) sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin, y2, z2), (xmax, y2, z2)) # top spine end if !(xaxis[:ticks] in (:none, nothing, false)) - f = scalefunc(yaxis[:scale]) - invf = invscalefunc(yaxis[:scale]) + f = scale_func(yaxis[:scale]) + invf = inverse_scale_func(yaxis[:scale]) tick_start, tick_stop = if sp[:framestyle] == :origin t = invf(f(0) + 0.012 * (f(ymax) - f(ymin))) (-t, t) @@ -869,8 +847,8 @@ function axis_drawing_info_3d(sp::Subplot) sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (x2, ymin, z2), (x2, ymax, z2)) # right spine end if !(yaxis[:ticks] in (:none, nothing, false)) - f = scalefunc(xaxis[:scale]) - invf = invscalefunc(xaxis[:scale]) + f = scale_func(xaxis[:scale]) + invf = inverse_scale_func(xaxis[:scale]) tick_start, tick_stop = if sp[:framestyle] == :origin t = invf(f(0) + 0.012 * (f(xmax) - f(xmin))) (-t, t) @@ -944,8 +922,8 @@ function axis_drawing_info_3d(sp::Subplot) sp[:framestyle] in (:semi, :box) && push!(zborder_segs, (x2, y2, zmin), (x2, y2, zmax)) end if !(zaxis[:ticks] in (:none, nothing, false)) - f = scalefunc(xaxis[:scale]) - invf = invscalefunc(xaxis[:scale]) + f = scale_func(xaxis[:scale]) + invf = inverse_scale_func(xaxis[:scale]) tick_start, tick_stop = if sp[:framestyle] == :origin t = invf(f(0) + 0.012 * (f(ymax) - f(ymin))) (-t, t) diff --git a/src/backends/hdf5.jl b/src/backends/hdf5.jl index 677d994e..4f38ee0d 100644 --- a/src/backends/hdf5.jl +++ b/src/backends/hdf5.jl @@ -83,7 +83,7 @@ if length(HDF5PLOT_MAP_TELEM2STR) < 1 "ARRAY" => Array, #Dict won't allow Array to be key in HDF5PLOT_MAP_TELEM2STR #Sub-structure types: - "ATTR" => Attr, + "DEFAULTSDICT" => DefaultsDict, "FONT" => Font, "BOUNDINGBOX" => BoundingBox, "GRIDLAYOUT" => GridLayout, @@ -395,12 +395,12 @@ function _hdf5plot_write(grp, plotattributes::KW) end return end -function _hdf5plot_write(grp, plotattributes::Attr) +function _hdf5plot_write(grp, plotattributes::DefaultsDict) for (k, v) in plotattributes kstr = string(k) _hdf5plot_gwrite(grp, kstr, v) end - _hdf5plot_writetype(grp, Attr) + _hdf5plot_writetype(grp, DefaultsDict) end @@ -558,14 +558,14 @@ parent = RootLayout() return GridLayout(parent, minpad, bbox, grid, widths, heights, attr) end -function _hdf5plot_read(grp, T::Type{Attr}) - attr = Attr(KW(), _plot_defaults) +function _hdf5plot_read(grp, T::Type{DefaultsDict}) + attr = DefaultsDict(KW(), _plot_defaults) v = _hdf5plot_read(grp, attr) return attr end function _hdf5plot_read(grp, k::String, T::Type{Axis}) grp = HDF5.g_open(grp, k) - plotattributes = Attr(KW(), _plot_defaults) + plotattributes = DefaultsDict(KW(), _plot_defaults) _hdf5plot_read(grp, plotattributes) return Axis([], plotattributes) end @@ -610,7 +610,7 @@ function _hdf5plot_readattr(grp, plotattributes::AbstractDict) return end _hdf5plot_read(grp, plotattributes::KW) = _hdf5plot_readattr(grp, plotattributes) -_hdf5plot_read(grp, plotattributes::Attr) = _hdf5plot_readattr(grp, plotattributes) +_hdf5plot_read(grp, plotattributes::DefaultsDict) = _hdf5plot_readattr(grp, plotattributes) # Read main plot structures: # ---------------------------------------------------------------- @@ -623,7 +623,7 @@ function _hdf5plot_read(sp::Subplot, subpath::String, f) for i in 1:nseries grp = HDF5.g_open(f, _hdf5_plotelempath("$subpath/series_list/series$i")) - seriesinfo = Attr(KW(), _plot_defaults) + seriesinfo = DefaultsDict(KW(), _plot_defaults) _hdf5plot_read(grp, seriesinfo) plot!(sp, seriesinfo[:x], seriesinfo[:y]) #Add data & create data structures _hdf5_merge!(sp.series_list[end].plotattributes, seriesinfo) @@ -631,7 +631,7 @@ function _hdf5plot_read(sp::Subplot, subpath::String, f) #Perform after adding series... otherwise values get overwritten: grp = HDF5.g_open(f, _hdf5_plotelempath("$subpath/attr")) - attr = Attr(KW(), _plot_defaults) + attr = DefaultsDict(KW(), _plot_defaults) _hdf5plot_read(grp, attr) _hdf5_merge!(sp.attr, attr) diff --git a/src/components.jl b/src/components.jl index 6aefa267..fa657a4d 100644 --- a/src/components.jl +++ b/src/components.jl @@ -595,8 +595,8 @@ function process_annotation(sp::Subplot, xs, ys, labs, font = font()) ylength = length(methods(length, (typeof(ys),))) == 0 ? 1 : length(ys) for i in 1:max(xlength, ylength, length(labs)) x, y, lab = _cycle(xs, i), _cycle(ys, i), _cycle(labs, i) - x = typeof(x) <: TimeType ? Dates.value(x) : x - y = typeof(y) <: TimeType ? Dates.value(y) : y + x = typeof(x) <: TimeType ? Dates.value(x) : x + y = typeof(y) <: TimeType ? Dates.value(y) : y if lab == :auto alphabet = "abcdefghijklmnopqrstuvwxyz" push!(anns, (x, y, text(string("(", alphabet[sp[:subplot_index]], ")"), font))) @@ -652,23 +652,6 @@ end # ----------------------------------------------------------------------- -abstract type AbstractSurface end - -"represents a contour or surface mesh" -struct Surface{M<:AMat} <: AbstractSurface - surf::M -end - -Surface(f::Function, x, y) = Surface(Float64[f(xi,yi) for yi in y, xi in x]) - -Base.Array(surf::Surface) = surf.surf - -for f in (:length, :size, :axes) - @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...) -end -Base.copy(surf::Surface) = Surface(copy(surf.surf)) -Base.eltype(surf::Surface{T}) where {T} = eltype(T) - function expand_extrema!(a::Axis, surf::Surface) ex = a[:extrema] for vi in surf.surf @@ -688,28 +671,7 @@ end # # I don't want to clash with ValidatedNumerics, but this would be nice: # ..(a::T, b::T) = (a,b) -struct Volume{T} - v::Array{T,3} - x_extents::Tuple{T,T} - y_extents::Tuple{T,T} - z_extents::Tuple{T,T} -end -default_extents(::Type{T}) where {T} = (zero(T), one(T)) - -function Volume(v::Array{T,3}, - x_extents = default_extents(T), - y_extents = default_extents(T), - z_extents = default_extents(T)) where T - Volume(v, x_extents, y_extents, z_extents) -end - -Base.Array(vol::Volume) = vol.v -for f in (:length, :size) - @eval Base.$f(vol::Volume, args...) = $f(vol.v, args...) -end -Base.copy(vol::Volume{T}) where {T} = Volume{T}(copy(vol.v), vol.x_extents, vol.y_extents, vol.z_extents) -Base.eltype(vol::Volume{T}) where {T} = T # ----------------------------------------------------------------------- @@ -773,14 +735,6 @@ function add_arrows(func::Function, x::AVec, y::AVec) end end -# ----------------------------------------------------------------------- - -"Represents data values with formatting that should apply to the tick labels." -struct Formatted{T} - data::T - formatter::Function -end - # ----------------------------------------------------------------------- "create a BezierCurve for plotting" mutable struct BezierCurve{T <: GeometryTypes.Point} diff --git a/src/pipeline.jl b/src/pipeline.jl index 8325d86a..d64958b4 100644 --- a/src/pipeline.jl +++ b/src/pipeline.jl @@ -1,127 +1,74 @@ -# Error for aliases used in recipes -function warn_on_recipe_aliases!(plotattributes, recipe_type, args...) +# RecipePipeline API + +## Warnings + +function RecipePipeline.warn_on_recipe_aliases!( + plt::Plot, + plotattributes, + recipe_type, + args..., +) for k in keys(plotattributes) if !is_default_attribute(k) dk = get(_keyAliases, k, k) if k !== dk - @warn "Attribute alias `$k` detected in the $recipe_type recipe defined for the signature $(signature_string(Val{recipe_type}, args...)). To ensure expected behavior it is recommended to use the default attribute `$dk`." + @warn "Attribute alias `$k` detected in the $recipe_type recipe defined for the signature $(_signature_string(Val{recipe_type}, args...)). To ensure expected behavior it is recommended to use the default attribute `$dk`." end plotattributes[dk] = pop_kw!(plotattributes, k) end end end -function warn_on_recipe_aliases!(v::AbstractVector, recipe_type, args...) - foreach(x -> warn_on_recipe_aliases!(x, recipe_type, args...), v) +function RecipePipeline.warn_on_recipe_aliases!( + plt::Plot, + v::AbstractVector, + recipe_type, + args..., +) + foreach(x -> RecipePipeline.warn_on_recipe_aliases!(plt, x, recipe_type, args...), v) end -function warn_on_recipe_aliases!(rd::RecipeData, recipe_type, args...) - warn_on_recipe_aliases!(rd.plotattributes, recipe_type, args...) +function RecipePipeline.warn_on_recipe_aliases!( + plt::Plot, + rd::RecipeData, + recipe_type, + args..., +) + RecipePipeline.warn_on_recipe_aliases!(plt, rd.plotattributes, recipe_type, args...) end -function signature_string(::Type{Val{:user}}, args...) +function _signature_string(::Type{Val{:user}}, args...) return string("(::", join(string.(typeof.(args)), ", ::"), ")") end -signature_string(::Type{Val{:type}}, T) = "(::Type{$T}, ::$T)" -signature_string(::Type{Val{:plot}}, st) = "(::Type{Val{:$st}}, ::AbstractPlot)" -signature_string(::Type{Val{:series}}, st) = "(::Type{Val{:$st}}, x, y, z)" +_signature_string(::Type{Val{:type}}, T) = "(::Type{$T}, ::$T)" +_signature_string(::Type{Val{:plot}}, st) = "(::Type{Val{:$st}}, ::AbstractPlot)" +_signature_string(::Type{Val{:series}}, st) = "(::Type{Val{:$st}}, x, y, z)" -# ------------------------------------------------------------------ -# preprocessing -function series_idx(kw_list::AVec{KW}, kw::AKW) - Int(kw[:series_plotindex]) - Int(kw_list[1][:series_plotindex]) + 1 +## Grouping + +RecipePipeline.splittable_attribute(plt::Plot, key, val::SeriesAnnotations, len) = + RecipePipeline.splittable_attribute(plt, key, val.strs, len) + +function RecipePipeline.split_attribute(plt::Plot, key, val::SeriesAnnotations, indices) + split_strs = _RecipePipeline.split_attribute(key, val.strs, indices) + return SeriesAnnotations(split_strs, val.font, val.baseshape, val.scalefactor) end -function _expand_seriestype_array(plotattributes::AKW, args) - sts = get(plotattributes, :seriestype, :path) - if typeof(sts) <: AbstractArray - reset_kw!(plotattributes, :seriestype) - rd = Vector{RecipeData}(undef, size(sts, 1)) - for r in axes(sts, 1) - dc = copy(plotattributes) - dc[:seriestype] = sts[r:r, :] - rd[r] = RecipeData(dc, args) - end - rd - else - RecipeData[RecipeData(copy(plotattributes), args)] - end -end -function _preprocess_args(plotattributes::AKW, args, still_to_process::Vector{RecipeData}) - # the grouping mechanism is a recipe on a GroupBy object - # we simply add the GroupBy object to the front of the args list to allow - # the recipe to be applied - if haskey(plotattributes, :group) - args = (_extract_group_attributes(plotattributes[:group], args...), args...) - end +## Preprocessing attributes - # if we were passed a vector/matrix of seriestypes and there's more than one row, - # we want to duplicate the inputs, once for each seriestype row. - if !isempty(args) - append!(still_to_process, _expand_seriestype_array(plotattributes, args)) - end +RecipePipeline.preprocess_attributes!(plt::Plot, plotattributes) = + preprocess_attributes!(plotattributes) # in src/args.jl - # remove subplot and axis args from plotattributes... - # they will be passed through in the kw_list - if !isempty(args) - for (k, v) in plotattributes - if k in _all_subplot_args || k in _all_axis_args - reset_kw!(plotattributes, k) - end - end - end +RecipePipeline.is_axis_attribute(plt::Plot, attr) = is_axis_attr_noletter(attr) # in src/args.jl - args -end - -# ------------------------------------------------------------------ -# user recipes +RecipePipeline.is_subplot_attribute(plt::Plot, attr) = is_subplot_attr(attr) # in src/args.jl -function _process_userrecipes(plt::Plot, plotattributes::AKW, args) - still_to_process = RecipeData[] - args = _preprocess_args(plotattributes, args, still_to_process) +## User recipes - # for plotting recipes, swap out the args and update the parameter dictionary - # we are keeping a stack of series that still need to be processed. - # each pass through the loop, we pop one off and apply the recipe. - # the recipe will return a list a Series objects... the ones that are - # finished (no more args) get added to the kw_list, the ones that are not - # are placed on top of the stack and are then processed further. - kw_list = KW[] - while !isempty(still_to_process) - # grab the first in line to be processed and either add it to the kw_list or - # pass it through apply_recipe to generate a list of RecipeData objects - # (data + attributes) for further processing. - next_series = popfirst!(still_to_process) - # recipedata should be of type RecipeData. - # if it's not then the inputs must not have been fully processed by recipes - if !(typeof(next_series) <: RecipeData) - error("Inputs couldn't be processed... expected RecipeData but got: $next_series") - end - if isempty(next_series.args) - _process_userrecipe(plt, kw_list, next_series) - else - rd_list = - RecipesBase.apply_recipe(next_series.plotattributes, next_series.args...) - warn_on_recipe_aliases!(rd_list, :user, next_series.args...) - prepend!(still_to_process, rd_list) - end - end - - # don't allow something else to handle it - plotattributes[:smooth] = false - kw_list -end - -function _process_userrecipe(plt::Plot, kw_list::Vector{KW}, recipedata::RecipeData) - # when the arg tuple is empty, that means there's nothing left to recursively - # process... finish up and add to the kw_list - kw = recipedata.plotattributes - preprocess_attributes!(kw) +function RecipePipeline.process_userrecipe!(plt::Plot, kw_list, kw) _preprocess_userrecipe(kw) warn_on_unsupported_scales(plt.backend, kw) - # add the plot index plt.n += 1 kw[:series_plotindex] = plt.n @@ -135,9 +82,6 @@ end function _preprocess_userrecipe(kw::AKW) _add_markershape(kw) - # if there was a grouping, filter the data here - _filter_input_data!(kw) - # map marker_z if it's a Function if isa(get(kw, :marker_z, nothing), Function) # TODO: should this take y and/or z as arguments? @@ -197,50 +141,23 @@ function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW) end end -# ------------------------------------------------------------------ -# plot recipes -# Grab the first in line to be processed and pass it through apply_recipe -# to generate a list of RecipeData objects (data + attributes). -# If we applied a "plot recipe" without error, then add the returned datalist's KWs, -# otherwise we just add the original KW. -function _process_plotrecipe( - plt::Plot, - kw::AKW, - kw_list::Vector{KW}, - still_to_process::Vector{KW}, -) - if !isa(get(kw, :seriestype, nothing), Symbol) - # seriestype was never set, or it's not a Symbol, so it can't be a plot recipe - push!(kw_list, kw) - return - end - try - st = kw[:seriestype] - st = kw[:seriestype] = get(_typeAliases, st, st) - datalist = RecipesBase.apply_recipe(kw, Val{st}, plt) - warn_on_recipe_aliases!(datalist, :plot, st) - for data in datalist - preprocess_attributes!(data.plotattributes) - if data.plotattributes[:seriestype] == st - error("Plot recipe $st returned the same seriestype: $(data.plotattributes)") - end - push!(still_to_process, data.plotattributes) - end - catch err - if isa(err, MethodError) - push!(kw_list, kw) - else - rethrow() - end - end - return +RecipePipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], :x) + + +## Plot recipes + +RecipePipeline.type_alias(plt::Plot) = get(_typeAliases, st, st) + + +## Plot setup + +function RecipePipeline.plot_setup!(plt::Plot, plotattributes, kw_list) + _plot_setup(plt, plotattributes, kw_list) + _subplot_setup(plt, plotattributes, kw_list) end - -# ------------------------------------------------------------------ -# setup plot and subplot - +# TODO: Should some of this logic be moved to RecipePipeline? function _plot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW}) # merge in anything meant for the Plot for kw in kw_list, (k, v) in kw @@ -345,6 +262,31 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW}) link_axes!(plt.layout, plt[:link]) end +function series_idx(kw_list::AVec{KW}, kw::AKW) + Int(kw[:series_plotindex]) - Int(kw_list[1][:series_plotindex]) + 1 +end + + +## Series recipes + +function RecipePipeline.slice_series_attributes!(plt::Plot, kw_list, kw) + sp::Subplot = kw[:subplot] + # in series attributes given as vector with one element per series, + # select the value for current series + _slice_series_args!(kw, plt, sp, series_idx(kw_list, kw)) +end + +RecipePipeline.series_defaults(plt::Plot) = _series_defaults # in args.jl + +RecipePipeline.is_seriestype_supported(plt::Plot, st) = is_seriestype_supported(st) + +function RecipePipeline.add_series!(plt::Plot, plotattributes) + sp = _prepare_subplot(plt, plotattributes) + _expand_subplot_extrema(sp, plotattributes, plotattributes[:seriestype]) + _update_series_attributes!(plotattributes, plt, sp) + _add_the_series(plt, sp, plotattributes) +end + # getting ready to add the series... last update to subplot from anything # that might have been added during series recipes function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where {T} @@ -356,7 +298,7 @@ function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where {T} st = _override_seriestype_check(plotattributes, st) # change to a 3d projection for this subplot? - if is3d(st) + if needs_3d_axes(st) sp.attr[:projection] = "3d" end @@ -368,9 +310,6 @@ function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where {T} sp end -# ------------------------------------------------------------------ -# series types - function _override_seriestype_check(plotattributes::AKW, st::Symbol) # do we want to override the series type? if !is3d(st) && !(st in (:contour, :contour3d)) @@ -409,48 +348,3 @@ function _add_the_series(plt, sp, plotattributes) push!(sp.series_list, series) _series_added(plt, series) end - -# ------------------------------------------------------------------------------- - -# this method recursively applies series recipes when the seriestype is not supported -# natively by the backend -function _process_seriesrecipe(plt::Plot, plotattributes::AKW) - # replace seriestype aliases - st = Symbol(plotattributes[:seriestype]) - st = plotattributes[:seriestype] = get(_typeAliases, st, st) - - # shapes shouldn't have fillrange set - if plotattributes[:seriestype] == :shape - plotattributes[:fillrange] = nothing - end - - # if it's natively supported, finalize processing and pass along to the backend, - # otherwise recurse - if is_seriestype_supported(st) - sp = _prepare_subplot(plt, plotattributes) - _expand_subplot_extrema(sp, plotattributes, st) - _update_series_attributes!(plotattributes, plt, sp) - _add_the_series(plt, sp, plotattributes) - - else - # get a sub list of series for this seriestype - x, y, z = plotattributes[:x], plotattributes[:y], plotattributes[:z] - datalist = RecipesBase.apply_recipe(plotattributes, Val{st}, x, y, z) - warn_on_recipe_aliases!(datalist, :series, st) - - # assuming there was no error, recursively apply the series recipes - for data in datalist - if isa(data, RecipeData) - preprocess_attributes!(data.plotattributes) - if data.plotattributes[:seriestype] == st - error("The seriestype didn't change in series recipe $st. This will cause a StackOverflow.") - end - _process_seriesrecipe(plt, data.plotattributes) - else - @warn("Unhandled recipe: $(data)") - break - end - end - end - nothing -end diff --git a/src/plot.jl b/src/plot.jl index 13653fee..eb91d772 100644 --- a/src/plot.jl +++ b/src/plot.jl @@ -163,87 +163,11 @@ end # this is the core plotting function. recursively apply recipes to build # a list of series KW dicts. # note: at entry, we only have those preprocessed args which were passed in... no default values yet -function _plot!(plt::Plot, plotattributes::AKW, args::Tuple) - plotattributes[:plot_object] = plt - - if !isempty(args) && !isdefined(Main, :StatsPlots) && - first(split(string(typeof(args[1])), ".")) == "DataFrames" - @warn("You're trying to plot a DataFrame, but this functionality is provided by StatsPlots") - end - - # -------------------------------- - # "USER RECIPES" - # -------------------------------- - - kw_list = _process_userrecipes(plt, plotattributes, args) - - # @info(1) - # map(DD, kw_list) - - - # -------------------------------- - # "PLOT RECIPES" - # -------------------------------- - - # "plot recipe", which acts like a series type, and is processed before - # the plot layout is created, which allows for setting layouts and other plot-wide attributes. - # we get inputs which have been fully processed by "user recipes" and "type recipes", - # so we can expect standard vectors, surfaces, etc. No defaults have been set yet. - still_to_process = kw_list - kw_list = KW[] - while !isempty(still_to_process) - next_kw = popfirst!(still_to_process) - _process_plotrecipe(plt, next_kw, kw_list, still_to_process) - end - - # @info(2) - # map(DD, kw_list) - - # -------------------------------- - # Plot/Subplot/Layout setup - # -------------------------------- - _plot_setup(plt, plotattributes, kw_list) - _subplot_setup(plt, plotattributes, kw_list) - - # !!! note: At this point, kw_list is fully decomposed into individual series... one KW per series. !!! - # !!! The next step is to recursively apply series recipes until the backend supports that series type !!! - - # -------------------------------- - # "SERIES RECIPES" - # -------------------------------- - - # @info(3) - # map(DD, kw_list) - - for kw in kw_list - sp::Subplot = kw[:subplot] - - # in series attributes given as vector with one element per series, - # select the value for current series - _slice_series_args!(kw, plt, sp, series_idx(kw_list,kw)) - - - series_attr = Attr(kw, _series_defaults) - # now we have a fully specified series, with colors chosen. we must recursively handle - # series recipes, which dispatch on seriestype. If a backend does not natively support a seriestype, - # we check for a recipe that will convert that series type into one made up of lower-level components. - # For example, a histogram is just a bar plot with binned data, a bar plot is really a filled step plot, - # and a step plot is really just a path. So any backend that supports drawing a path will implicitly - # be able to support step, bar, and histogram plots (and any recipes that use those components). - _process_seriesrecipe(plt, series_attr) - end - - # -------------------------------- - +function _plot!(plt::Plot, plotattributes, args) + RecipePipeline.recipe_pipeline!(plt, plotattributes, args) current(plt) - - # do we want to force display? - # if plt[:show] - # gui(plt) - # end _do_plot_show(plt, plt[:show]) - - plt + return plt end diff --git a/src/recipes.jl b/src/recipes.jl index 5969528d..666b9e7f 100644 --- a/src/recipes.jl +++ b/src/recipes.jl @@ -457,6 +457,8 @@ end () end @deps plots_heatmap shape +is_3d(::Type{Val{:plots_heatmap}}) = true +is_surface(::Type{Val{:plots_heatmap}}) = true # --------------------------------------------------------------------------- # Histograms diff --git a/src/series.jl b/src/series.jl index 11cf7493..cfc1cc7a 100644 --- a/src/series.jl +++ b/src/series.jl @@ -1,411 +1,7 @@ - - -# create a new "build_series_args" which converts all inputs into xs = Any[xitems], ys = Any[yitems]. -# Special handling for: no args, xmin/xmax, parametric, dataframes -# Then once inputs have been converted, build the series args, map functions, etc. -# This should cut down on boilerplate code and allow more focused dispatch on type -# note: returns meta information... mainly for use with automatic labeling from DataFrames for now - -const FuncOrFuncs{F} = Union{F, Vector{F}, Matrix{F}} -const MaybeNumber = Union{Number, Missing} -const MaybeString = Union{AbstractString, Missing} -const DataPoint = Union{MaybeNumber, MaybeString} - -prepare_series_data(x) = error("Cannot convert $(typeof(x)) to series data for plotting") -prepare_series_data(::Nothing) = nothing -prepare_series_data(t::Tuple{T, T}) where {T <: Number} = t -prepare_series_data(f::Function) = f -prepare_series_data(ar::AbstractRange{<:Number}) = ar -function prepare_series_data(a::AbstractArray{<:MaybeNumber}) - f = isimmutable(a) ? replace : replace! - a = f(x -> ismissing(x) || isinf(x) ? NaN : x, map(float, a)) -end -prepare_series_data(a::AbstractArray{<:Missing}) = fill(NaN, axes(a)) -prepare_series_data(a::AbstractArray{<:MaybeString}) = - replace(x -> ismissing(x) ? "" : x, a) -prepare_series_data(s::Surface{<:AMat{<:MaybeNumber}}) = - Surface(prepare_series_data(s.surf)) -prepare_series_data(s::Surface) = s # non-numeric Surface, such as an image -prepare_series_data(v::Volume) = - Volume(prepare_series_data(v.v), v.x_extents, v.y_extents, v.z_extents) - -# default: assume x represents a single series -series_vector(x, plotattributes) = [prepare_series_data(x)] - -# fixed number of blank series -series_vector(n::Integer, plotattributes) = [zeros(0) for i in 1:n] - -# vector of data points is a single series -series_vector(v::AVec{<:DataPoint}, plotattributes) = [prepare_series_data(v)] - -# list of things (maybe other vectors, functions, or something else) -function series_vector(v::AVec, plotattributes) - if all(x -> x isa MaybeNumber, v) - series_vector(Vector{MaybeNumber}(v), plotattributes) - elseif all(x -> x isa MaybeString, v) - series_vector(Vector{MaybeString}(v), plotattributes) - else - vcat((series_vector(vi, plotattributes) for vi in v)...) - end -end - -# Matrix is split into columns -function series_vector(v::AMat{<:DataPoint}, plotattributes) - if all3D(plotattributes) - [prepare_series_data(Surface(v))] - else - [prepare_series_data(v[:, i]) for i in axes(v, 2)] - end -end - -# -------------------------------------------------------------------- -# Fillranges & ribbons - - -process_fillrange(range::Number, plotattributes) = [range] -process_fillrange(range, plotattributes) = series_vector(range, plotattributes) - -process_ribbon(ribbon::Number, plotattributes) = [ribbon] -process_ribbon(ribbon, plotattributes) = series_vector(ribbon, plotattributes) -# ribbon as a tuple: (lower_ribbons, upper_ribbons) -process_ribbon(ribbon::Tuple{S, T}, plotattributes) where {S, T} = collect(zip( - series_vector(ribbon[1], plotattributes), - series_vector(ribbon[2], plotattributes), -)) - - -# -------------------------------------------------------------------- - -compute_x(x::Nothing, y::Nothing, z) = axes(z, 1) -compute_x(x::Nothing, y, z) = axes(y, 1) -compute_x(x::Function, y, z) = map(x, y) -compute_x(x, y, z) = x - -compute_y(x::Nothing, y::Nothing, z) = axes(z, 2) -compute_y(x, y::Function, z) = map(y, x) -compute_y(x, y, z) = y - -compute_z(x, y, z::Function) = map(z, x, y) -compute_z(x, y, z::AbstractMatrix) = Surface(z) -compute_z(x, y, z::Nothing) = nothing -compute_z(x, y, z) = z - -nobigs(v::AVec{BigFloat}) = map(Float64, v) -nobigs(v::AVec{BigInt}) = map(Int64, v) -nobigs(v) = v - -@noinline function compute_xyz(x, y, z) - x = compute_x(x, y, z) - y = compute_y(x, y, z) - z = compute_z(x, y, z) - nobigs(x), nobigs(y), nobigs(z) -end - -# not allowed -compute_xyz(x::Nothing, y::FuncOrFuncs{F}, z) where {F <: Function} = - error("If you want to plot the function `$y`, you need to define the x values!") -compute_xyz(x::Nothing, y::Nothing, z::FuncOrFuncs{F}) where {F <: Function} = - error("If you want to plot the function `$z`, you need to define x and y values!") -compute_xyz(x::Nothing, y::Nothing, z::Nothing) = error("x/y/z are all nothing!") - -# -------------------------------------------------------------------- - - -# we are going to build recipes to do the processing and splitting of the args - -# -------------------------------------------------------------------- -# The catch-all SliceIt recipe -# -------------------------------------------------------------------- - -# ensure we dispatch to the slicer -struct SliceIt end - -# The `SliceIt` recipe finishes user and type recipe processing. -# It splits processed data into individual series data, stores in copied `plotattributes` -# for each series and returns no arguments. -@recipe function f(::Type{SliceIt}, x, y, z) - - # handle data with formatting attached - if typeof(x) <: Formatted - xformatter := x.formatter - x = x.data - end - if typeof(y) <: Formatted - yformatter := y.formatter - y = y.data - end - if typeof(z) <: Formatted - zformatter := z.formatter - z = z.data - end - - xs = series_vector(x, plotattributes) - ys = series_vector(y, plotattributes) - zs = series_vector(z, plotattributes) - - fr = pop!(plotattributes, :fillrange, nothing) - fillranges = process_fillrange(fr, plotattributes) - mf = length(fillranges) - - rib = pop!(plotattributes, :ribbon, nothing) - ribbons = process_ribbon(rib, plotattributes) - mr = length(ribbons) - - mx = length(xs) - my = length(ys) - mz = length(zs) - if mx > 0 && my > 0 && mz > 0 - for i in 1:max(mx, my, mz) - # add a new series - di = copy(plotattributes) - xi, yi, zi = xs[mod1(i, mx)], ys[mod1(i, my)], zs[mod1(i, mz)] - di[:x], di[:y], di[:z] = compute_xyz(xi, yi, zi) - - # handle fillrange - fr = fillranges[mod1(i, mf)] - di[:fillrange] = isa(fr, Function) ? map(fr, di[:x]) : fr - - # handle ribbons - rib = ribbons[mod1(i, mr)] - di[:ribbon] = isa(rib, Function) ? map(rib, di[:x]) : rib - - push!(series_list, RecipeData(di, ())) - end - end - nothing # don't add a series for the main block -end - - -# -------------------------------------------------------------------- -# Apply type recipes -# -------------------------------------------------------------------- - -# this is the default "type recipe"... just pass the object through -@recipe f(::Type{T}, v::T) where {T} = v - -# this should catch unhandled "series recipes" and error with a nice message -@recipe f(::Type{V}, x, y, z) where {V <: Val} = - error("The backend must not support the series type $V, and there isn't a series recipe defined.") - -function _apply_type_recipe(plotattributes, v, letter) - _preprocess_axis_args!(plotattributes, letter) - rdvec = RecipesBase.apply_recipe(plotattributes, typeof(v), v) - warn_on_recipe_aliases!(plotattributes, :type, typeof(v)) - _postprocess_axis_args!(plotattributes, letter) - return rdvec[1].args[1] -end - -# Handle type recipes when the recipe is defined on the elements. -# This sort of recipe should return a pair of functions... one to convert to number, -# and one to format tick values. -function _apply_type_recipe(plotattributes, v::AbstractArray, letter) - _preprocess_axis_args!(plotattributes, letter) - # First we try to apply an array type recipe. - w = RecipesBase.apply_recipe(plotattributes, typeof(v), v)[1].args[1] - warn_on_recipe_aliases!(plotattributes, :type, typeof(v)) - # If the type did not change try it element-wise - if typeof(v) == typeof(w) - isempty(skipmissing(v)) && return Float64[] - x = first(skipmissing(v)) - args = RecipesBase.apply_recipe(plotattributes, typeof(x), x)[1].args - warn_on_recipe_aliases!(plotattributes, :type, typeof(x)) - _postprocess_axis_args!(plotattributes, letter) - if length(args) == 2 && all(arg -> arg isa Function, args) - numfunc, formatter = args - return Formatted(map(numfunc, v), formatter) - else - return v - end - end - _postprocess_axis_args!(plotattributes, letter) - return w -end - -# special handling for Surface... need to properly unwrap and re-wrap -_apply_type_recipe( - plotattributes, - v::Surface{<:AMat{<:Union{AbstractFloat, Integer, AbstractString, Missing}}}, - letter, -) = v -function _apply_type_recipe(plotattributes, v::Surface, letter) - ret = _apply_type_recipe(plotattributes, v.surf, letter) - if typeof(ret) <: Formatted - Formatted(Surface(ret.data), ret.formatter) - else - Surface(ret) - end -end - -# don't do anything vectors of datapoints and for nothing -_apply_type_recipe(plotattributes, v::Nothing, letter) = v -_apply_type_recipe( - plotattributes, - v::AbstractArray{<:Union{AbstractFloat, Integer, AbstractString, Missing}}, - letter, -) = v - -# axis args before type recipes should still be mapped to all axes -function _preprocess_axis_args!(plotattributes) - for (k, v) in plotattributes - if is_axis_attr_noletter(k) - pop!(plotattributes, k) - for l in (:x, :y, :z) - lk = Symbol(l, k) - haskey(plotattributes, lk) || (plotattributes[lk] = v) - end - end - end -end -function _preprocess_axis_args!(plotattributes, letter) - plotattributes[:letter] = letter - _preprocess_axis_args!(plotattributes) -end - -# axis args in type recipes should only be applied to the current axis -function _postprocess_axis_args!(plotattributes, letter) - pop!(plotattributes, :letter) - if letter in (:x, :y, :z) - for (k, v) in plotattributes - if is_axis_attr_noletter(k) - pop!(plotattributes, k) - lk = Symbol(letter, k) - haskey(plotattributes, lk) || (plotattributes[lk] = v) - end - end - end -end - - -# -------------------------------------------------------------------- -# Fallback user recipes calling type recipes -# -------------------------------------------------------------------- - -# handle "type recipes" by converting inputs, and then either re-calling or slicing -@recipe function f(x, y, z) - wrap_surfaces!(plotattributes, x, y, z) - did_replace = false - newx = _apply_type_recipe(plotattributes, x, :x) - x === newx || (did_replace = true) - newy = _apply_type_recipe(plotattributes, y, :y) - y === newy || (did_replace = true) - newz = _apply_type_recipe(plotattributes, z, :z) - z === newz || (did_replace = true) - if did_replace - newx, newy, newz - else - SliceIt, x, y, z - end -end -@recipe function f(x, y) - wrap_surfaces!(plotattributes, x, y) - did_replace = false - newx = _apply_type_recipe(plotattributes, x, :x) - x === newx || (did_replace = true) - newy = _apply_type_recipe(plotattributes, y, :y) - y === newy || (did_replace = true) - if did_replace - newx, newy - else - SliceIt, x, y, nothing - end -end -@recipe function f(y) - wrap_surfaces!(plotattributes, y) - newy = _apply_type_recipe(plotattributes, y, :y) - if y !== newy - newy - else - SliceIt, nothing, y, nothing - end -end - -# if there's more than 3 inputs, it can't be passed directly to SliceIt -# so we'll apply_type_recipe to all of them -@recipe function f(v1, v2, v3, v4, vrest...) - did_replace = false - newargs = map( - v -> begin - newv = _apply_type_recipe(plotattributes, v, :unknown) - if newv !== v - did_replace = true - end - newv - end, - (v1, v2, v3, v4, vrest...), - ) - if !did_replace - error("Couldn't process recipe args: $(map(typeof, (v1, v2, v3, v4, vrest...)))") - end - newargs -end - - -# helper function to ensure relevant attributes are wrapped by Surface -function wrap_surfaces!(plotattributes, args...) end -wrap_surfaces!(plotattributes, x::AMat, y::AMat, z::AMat) = wrap_surfaces!(plotattributes) -wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::AMat) = wrap_surfaces!(plotattributes) -function wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::Surface) - wrap_surfaces!(plotattributes) -end -function wrap_surfaces!(plotattributes) - if haskey(plotattributes, :fill_z) - v = plotattributes[:fill_z] - if !isa(v, Surface) - plotattributes[:fill_z] = Surface(v) - end - end -end - - # -------------------------------------------------------------------- # 1 argument # -------------------------------------------------------------------- -@recipe f(n::Integer) = is3d(get(plotattributes, :seriestype, :path)) ? (SliceIt, n, n, n) : - (SliceIt, n, n, nothing) - -all3D(plotattributes) = trueOrAllTrue( - st -> st in ( - :contour, - :contourf, - :heatmap, - :surface, - :wireframe, - :contour3d, - :image, - :plots_heatmap, - ), - get(plotattributes, :seriestype, :none), -) - -# return a surface if this is a 3d plot, otherwise let it be sliced up -@recipe function f(mat::AMat) - if all3D(plotattributes) - n, m = axes(mat) - m, n, Surface(mat) - else - nothing, mat, nothing - end -end - -# if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface -@recipe function f(fmt::Formatted{<:AMat}) - if all3D(plotattributes) - mat = fmt.data - n, m = axes(mat) - m, n, Formatted(Surface(mat), fmt.formatter) - else - nothing, fmt, nothing - end -end - -# assume this is a Volume, so construct one -@recipe function f(vol::AbstractArray{<:MaybeNumber, 3}, args...) - seriestype := :volume - SliceIt, nothing, Volume(vol, args...), nothing -end - - # images - grays function clamp_greys!(mat::AMat{<:Gray}) for i in eachindex(mat) @@ -467,61 +63,11 @@ end end end -# Dicts: each entry is a data point (x,y)=(key,value) - -@recipe f(d::AbstractDict) = collect(keys(d)), collect(values(d)) - -# function without range... use the current range of the x-axis - -@recipe function f(f::FuncOrFuncs{F}) where {F <: Function} - plt = plotattributes[:plot_object] - xmin, xmax = if haskey(plotattributes, :xlims) - plotattributes[:xlims] - else - try - axis_limits(plt[1], :x) - catch - xinv = invscalefunc(get(plotattributes, :xscale, :identity)) - xm = PlotUtils.tryrange(f, xinv.([-5, -1, 0, 0.01])) - xm, PlotUtils.tryrange(f, filter(x -> x > xm, xinv.([5, 1, 0.99, 0, -0.01]))) - end - end - - f, xmin, xmax -end - - -# -------------------------------------------------------------------- -# 2 arguments -# -------------------------------------------------------------------- - -# if functions come first, just swap the order (not to be confused with parametric -# functions... as there would be more than one function passed in) - -@recipe function f(f::FuncOrFuncs{F}, x) where {F <: Function} - F2 = typeof(x) - @assert !(F2 <: Function || (F2 <: AbstractArray && F2.parameters[1] <: Function)) # otherwise we'd hit infinite recursion here - x, f -end - # -------------------------------------------------------------------- # 3 arguments # -------------------------------------------------------------------- -# surface-like... function -@recipe function f(x::AVec, y::AVec, zf::Function) - x, y, Surface(zf, x, y) # TODO: replace with SurfaceFunction when supported -end - -# surface-like... matrix grid -@recipe function f(x::AVec, y::AVec, z::AMat) - if !like_surface(get(plotattributes, :seriestype, :none)) - plotattributes[:seriestype] = :contour - end - x, y, Surface(z) -end - # images - grays @recipe function f(x::AVec, y::AVec, mat::AMat{T}) where {T <: Gray} if is_seriestype_supported(:image) @@ -552,152 +98,13 @@ end end end - -# -------------------------------------------------------------------- -# Parametric functions -# -------------------------------------------------------------------- - -# special handling... xmin/xmax with parametric function(s) -@recipe function f(f::Function, xmin::Number, xmax::Number) - xscale, yscale = [get(plotattributes, sym, :identity) for sym in (:xscale, :yscale)] - _scaled_adapted_grid(f, xscale, yscale, xmin, xmax) -end -@recipe function f(fs::AbstractArray{F}, xmin::Number, xmax::Number) where {F <: Function} - xscale, yscale = [get(plotattributes, sym, :identity) for sym in (:xscale, :yscale)] - unzip(_scaled_adapted_grid.(fs, xscale, yscale, xmin, xmax)) -end -@recipe f( - fx::FuncOrFuncs{F}, - fy::FuncOrFuncs{G}, - u::AVec, -) where {F <: Function, G <: Function} = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u) -@recipe f( - fx::FuncOrFuncs{F}, - fy::FuncOrFuncs{G}, - umin::Number, - umax::Number, - n = 200, -) where {F <: Function, G <: Function} = fx, fy, range(umin, stop = umax, length = n) - -function _scaled_adapted_grid(f, xscale, yscale, xmin, xmax) - (xf, xinv), (yf, yinv) = ((scalefunc(s), invscalefunc(s)) for s in (xscale, yscale)) - xs, ys = adapted_grid(yf ∘ f ∘ xinv, xf.((xmin, xmax))) - xinv.(xs), yinv.(ys) -end - -# special handling... 3D parametric function(s) -@recipe function f( - fx::FuncOrFuncs{F}, - fy::FuncOrFuncs{G}, - fz::FuncOrFuncs{H}, - u::AVec, -) where {F <: Function, G <: Function, H <: Function} - mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u) -end -@recipe function f( - fx::FuncOrFuncs{F}, - fy::FuncOrFuncs{G}, - fz::FuncOrFuncs{H}, - umin::Number, - umax::Number, - numPoints = 200, -) where {F <: Function, G <: Function, H <: Function} - fx, fy, fz, range(umin, stop = umax, length = numPoints) -end - - # -------------------------------------------------------------------- # Lists of tuples and GeometryTypes.Points # -------------------------------------------------------------------- - -@recipe f(v::AVec{<:Tuple}) = unzip(v) @recipe f(v::AVec{<:GeometryTypes.Point}) = unzip(v) -@recipe f(tup::Tuple) = [tup] @recipe f(p::GeometryTypes.Point) = [p] # Special case for 4-tuples in :ohlc series @recipe f(xyuv::AVec{<:Tuple{R1, R2, R3, R4}}) where {R1, R2, R3, R4} = get(plotattributes, :seriestype, :path) == :ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv) - - -# -------------------------------------------------------------------- -# handle grouping -# -------------------------------------------------------------------- - -splittable_kw(key, val, lengthGroup) = false -splittable_kw(key, val::AbstractArray, lengthGroup) = - !(key in (:group, :color_palette)) && length(axes(val, 1)) == lengthGroup -splittable_kw(key, val::Tuple, lengthGroup) = all(splittable_kw.(key, val, lengthGroup)) -splittable_kw(key, val::SeriesAnnotations, lengthGroup) = - splittable_kw(key, val.strs, lengthGroup) - -split_kw(key, val::AbstractArray, indices) = val[indices, fill(Colon(), ndims(val) - 1)...] -split_kw(key, val::Tuple, indices) = Tuple(split_kw(key, v, indices) for v in val) -function split_kw(key, val::SeriesAnnotations, indices) - split_strs = split_kw(key, val.strs, indices) - return SeriesAnnotations(split_strs, val.font, val.baseshape, val.scalefactor) -end - -function groupedvec2mat(x_ind, x, y::AbstractArray, groupby, def_val = y[1]) - y_mat = Array{promote_type(eltype(y), typeof(def_val))}( - undef, - length(keys(x_ind)), - length(groupby.groupLabels), - ) - fill!(y_mat, def_val) - for i in eachindex(groupby.groupLabels) - xi = x[groupby.groupIds[i]] - yi = y[groupby.groupIds[i]] - y_mat[getindex.(Ref(x_ind), xi), i] = yi - end - return y_mat -end - -groupedvec2mat(x_ind, x, y::Tuple, groupby) = - Tuple(groupedvec2mat(x_ind, x, v, groupby) for v in y) - -group_as_matrix(t) = false - -# split the group into 1 series per group, and set the label and idxfilter for each -@recipe function f(groupby::GroupBy, args...) - lengthGroup = maximum(union(groupby.groupIds...)) - if !(group_as_matrix(args[1])) - for (i, glab) in enumerate(groupby.groupLabels) - @series begin - label --> string(glab) - idxfilter --> groupby.groupIds[i] - for (key, val) in plotattributes - if splittable_kw(key, val, lengthGroup) - :($key) := split_kw(key, val, groupby.groupIds[i]) - end - end - args - end - end - else - g = args[1] - if length(g.args) == 1 - x = zeros(Int, lengthGroup) - for indexes in groupby.groupIds - x[indexes] = eachindex(indexes) - end - last_args = g.args - else - x = g.args[1] - last_args = g.args[2:end] - end - x_u = unique(sort(x)) - x_ind = Dict(zip(x_u, eachindex(x_u))) - for (key, val) in plotattributes - if splittable_kw(key, val, lengthGroup) - :($key) := groupedvec2mat(x_ind, x, val, groupby) - end - end - label --> reshape(groupby.groupLabels, 1, :) - typeof(g)(( - x_u, - (groupedvec2mat(x_ind, x, arg, groupby, NaN) for arg in last_args)..., - )) - end -end diff --git a/src/subplots.jl b/src/subplots.jl index 131ccfe2..ef6efda5 100644 --- a/src/subplots.jl +++ b/src/subplots.jl @@ -7,7 +7,7 @@ function Subplot(::T; parent = RootLayout()) where T<:AbstractBackend (20mm, 5mm, 2mm, 10mm), defaultbox, defaultbox, - Attr(KW(), _subplot_defaults), + DefaultsDict(KW(), _subplot_defaults), nothing, nothing ) diff --git a/src/types.jl b/src/types.jl index a866e59f..5a7427c5 100644 --- a/src/types.jl +++ b/src/types.jl @@ -18,65 +18,10 @@ end wrap(obj::T) where {T} = InputWrapper{T}(obj) Base.isempty(wrapper::InputWrapper) = false - -# ----------------------------------------------------------- - -struct Attr <: AbstractDict{Symbol,Any} - explicit::KW - defaults::KW -end - -function Base.getindex(attr::Attr, k) - return haskey(attr.explicit, k) ? attr.explicit[k] : attr.defaults[k] -end -Base.haskey(attr::Attr, k) = haskey(attr.explicit,k) || haskey(attr.defaults,k) -Base.get(attr::Attr, k, default) = haskey(attr, k) ? attr[k] : default -function Base.get!(attr::Attr, k, default) - v = if haskey(attr, k) - attr[k] - else - attr.defaults[k] = default - end - return v -end -function Base.delete!(attr::Attr, k) - haskey(attr.explicit, k) && delete!(attr.explicit, k) - haskey(attr.defaults, k) && delete!(attr.defaults, k) -end -Base.length(attr::Attr) = length(union(keys(attr.explicit), keys(attr.defaults))) -function Base.iterate(attr::Attr) - exp_keys = keys(attr.explicit) - def_keys = setdiff(keys(attr.defaults), exp_keys) - key_list = collect(Iterators.flatten((exp_keys, def_keys))) - iterate(attr, (key_list, 1)) -end -function Base.iterate(attr::Attr, (key_list, i)) - i > length(key_list) && return nothing - k = key_list[i] - (k=>attr[k], (key_list, i+1)) -end - -Base.copy(attr::Attr) = Attr(copy(attr.explicit), attr.defaults) - -RecipesBase.is_explicit(attr::Attr, k) = haskey(attr.explicit,k) -isdefault(attr::Attr, k) = !is_explicit(attr,k) && haskey(attr.defaults,k) - -Base.setindex!(attr::Attr, v, k) = attr.explicit[k] = v - -# Reset to default value and return dict -reset_kw!(attr::Attr, k) = is_explicit(attr, k) ? delete!(attr.explicit, k) : attr -# Reset to default value and return old value -pop_kw!(attr::Attr, k) = is_explicit(attr, k) ? pop!(attr.explicit, k) : attr.defaults[k] -pop_kw!(attr::Attr, k, default) = is_explicit(attr, k) ? pop!(attr.explicit, k) : get(attr.defaults, k, default) -# Fallbacks for dicts without defaults -reset_kw!(d::AKW, k) = delete!(d, k) -pop_kw!(d::AKW, k) = pop!(d, k) -pop_kw!(d::AKW, k, default) = pop!(d, k, default) - # ----------------------------------------------------------- mutable struct Series - plotattributes::Attr + plotattributes::DefaultsDict end attr(series::Series, k::Symbol) = series.plotattributes[k] @@ -91,7 +36,7 @@ mutable struct Subplot{T<:AbstractBackend} <: AbstractLayout minpad::Tuple # leftpad, toppad, rightpad, bottompad bbox::BoundingBox # the canvas area which is available to this subplot plotarea::BoundingBox # the part where the data goes - attr::Attr # args specific to this subplot + attr::DefaultsDict # args specific to this subplot o # can store backend-specific data... like a pyplot ax plt # the enclosing Plot object (can't give it a type because of no forward declarations) end @@ -103,7 +48,7 @@ Base.show(io::IO, sp::Subplot) = print(io, "Subplot{$(sp[:subplot_index])}") # simple wrapper around a KW so we can hold all attributes pertaining to the axis in one place mutable struct Axis sps::Vector{Subplot} - plotattributes::Attr + plotattributes::DefaultsDict end mutable struct Extrema @@ -122,7 +67,7 @@ const SubplotMap = Dict{Any, Subplot} mutable struct Plot{T<:AbstractBackend} <: AbstractPlot{T} backend::T # the backend type n::Int # number of series - attr::Attr # arguments for the whole plot + attr::DefaultsDict # arguments for the whole plot series_list::Vector{Series} # arguments for each series o # the backend's plot object subplots::Vector{Subplot} @@ -133,7 +78,7 @@ mutable struct Plot{T<:AbstractBackend} <: AbstractPlot{T} end function Plot() - Plot(backend(), 0, Attr(KW(), _plot_defaults), Series[], nothing, + Plot(backend(), 0, DefaultsDict(KW(), _plot_defaults), Series[], nothing, Subplot[], SubplotMap(), EmptyLayout(), Subplot[], false) end diff --git a/src/utils.jl b/src/utils.jl index 42f905c6..bb6c5bd1 100644 --- a/src/utils.jl +++ b/src/utils.jl @@ -143,9 +143,6 @@ makevec(v::T) where {T} = T[v] maketuple(x::Real) = (x,x) maketuple(x::Tuple{T,S}) where {T,S} = x -mapFuncOrFuncs(f::Function, u::AVec) = map(f, u) -mapFuncOrFuncs(fs::AVec{F}, u::AVec) where {F<:Function} = [map(f, u) for f in fs] - for i in 2:4 @eval begin unzip(v::Union{AVec{<:Tuple{Vararg{T,$i} where T}}, @@ -229,7 +226,7 @@ end "create an (n+1) list of the outsides of heatmap rectangles" function heatmap_edges(v::AVec, scale::Symbol = :identity, isedges::Bool = false) - f, invf = scalefunc(scale), invscalefunc(scale) + f, invf = scale_func(scale), inverse_scale_func(scale) map(invf, _heatmap_edges(map(f,v), isedges)) end From bd9cd64e7a5ae2d0fe3d04649830ff0a718725a2 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Sat, 4 Apr 2020 17:32:45 +0200 Subject: [PATCH 03/17] move remaining user recipes in series.jl to recipes.jl --- src/Plots.jl | 1 - src/recipes.jl | 112 +++++++++++++++++++++++++++++++++++++++++++++++++ src/series.jl | 110 ------------------------------------------------ 3 files changed, 112 insertions(+), 111 deletions(-) delete mode 100644 src/series.jl diff --git a/src/Plots.jl b/src/Plots.jl index bf1571b7..edde93f2 100644 --- a/src/Plots.jl +++ b/src/Plots.jl @@ -193,7 +193,6 @@ include("args.jl") include("themes.jl") include("plot.jl") include("pipeline.jl") -include("series.jl") include("layouts.jl") include("subplots.jl") include("recipes.jl") diff --git a/src/recipes.jl b/src/recipes.jl index 666b9e7f..5b8d6694 100644 --- a/src/recipes.jl +++ b/src/recipes.jl @@ -1180,6 +1180,118 @@ end @deps quiver shape path +# -------------------------------------------------------------------- +# 1 argument +# -------------------------------------------------------------------- + +# images - grays +function clamp_greys!(mat::AMat{<:Gray}) + for i in eachindex(mat) + mat[i].val < 0 && (mat[i] = Gray(0)) + mat[i].val > 1 && (mat[i] = Gray(1)) + end + mat +end + +@recipe function f(mat::AMat{<:Gray}) + n, m = axes(mat) + if is_seriestype_supported(:image) + seriestype := :image + yflip --> true + SliceIt, m, n, Surface(clamp_greys!(mat)) + else + seriestype := :heatmap + yflip --> true + cbar --> false + fillcolor --> ColorGradient([:black, :white]) + SliceIt, m, n, Surface(clamp!(convert(Matrix{Float64}, mat), 0.0, 1.0)) + end +end + +# images - colors +@recipe function f(mat::AMat{T}) where {T <: Colorant} + n, m = axes(mat) + + if is_seriestype_supported(:image) + seriestype := :image + yflip --> true + SliceIt, m, n, Surface(mat) + else + seriestype := :heatmap + yflip --> true + cbar --> false + aspect_ratio --> :equal + z, plotattributes[:fillcolor] = replace_image_with_heatmap(mat) + SliceIt, m, n, Surface(z) + end +end + +# plotting arbitrary shapes/polygons + +@recipe function f(shape::Shape) + seriestype --> :shape + coords(shape) +end + +@recipe function f(shapes::AVec{Shape}) + seriestype --> :shape + coords(shapes) +end + +@recipe function f(shapes::AMat{Shape}) + seriestype --> :shape + for j in axes(shapes, 2) + @series coords(vec(shapes[:, j])) + end +end + + +# -------------------------------------------------------------------- +# 3 arguments +# -------------------------------------------------------------------- + +# images - grays +@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where {T <: Gray} + if is_seriestype_supported(:image) + seriestype := :image + yflip --> true + SliceIt, x, y, Surface(mat) + else + seriestype := :heatmap + yflip --> true + cbar --> false + fillcolor --> ColorGradient([:black, :white]) + SliceIt, x, y, Surface(convert(Matrix{Float64}, mat)) + end +end + +# images - colors +@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where {T <: Colorant} + if is_seriestype_supported(:image) + seriestype := :image + yflip --> true + SliceIt, x, y, Surface(mat) + else + seriestype := :heatmap + yflip --> true + cbar --> false + z, plotattributes[:fillcolor] = replace_image_with_heatmap(mat) + SliceIt, x, y, Surface(z) + end +end + +# -------------------------------------------------------------------- +# Lists of tuples and GeometryTypes.Points +# -------------------------------------------------------------------- +@recipe f(v::AVec{<:GeometryTypes.Point}) = unzip(v) +@recipe f(p::GeometryTypes.Point) = [p] + +# Special case for 4-tuples in :ohlc series +@recipe f(xyuv::AVec{<:Tuple{R1, R2, R3, R4}}) where {R1, R2, R3, R4} = + get(plotattributes, :seriestype, :path) == :ohlc ? OHLC[OHLC(t...) for t in xyuv] : + unzip(xyuv) + + # ------------------------------------------------- # TODO: move OHLC to PlotRecipes finance.jl diff --git a/src/series.jl b/src/series.jl deleted file mode 100644 index cfc1cc7a..00000000 --- a/src/series.jl +++ /dev/null @@ -1,110 +0,0 @@ -# -------------------------------------------------------------------- -# 1 argument -# -------------------------------------------------------------------- - -# images - grays -function clamp_greys!(mat::AMat{<:Gray}) - for i in eachindex(mat) - mat[i].val < 0 && (mat[i] = Gray(0)) - mat[i].val > 1 && (mat[i] = Gray(1)) - end - mat -end - -@recipe function f(mat::AMat{<:Gray}) - n, m = axes(mat) - if is_seriestype_supported(:image) - seriestype := :image - yflip --> true - SliceIt, m, n, Surface(clamp_greys!(mat)) - else - seriestype := :heatmap - yflip --> true - cbar --> false - fillcolor --> ColorGradient([:black, :white]) - SliceIt, m, n, Surface(clamp!(convert(Matrix{Float64}, mat), 0.0, 1.0)) - end -end - -# images - colors -@recipe function f(mat::AMat{T}) where {T <: Colorant} - n, m = axes(mat) - - if is_seriestype_supported(:image) - seriestype := :image - yflip --> true - SliceIt, m, n, Surface(mat) - else - seriestype := :heatmap - yflip --> true - cbar --> false - aspect_ratio --> :equal - z, plotattributes[:fillcolor] = replace_image_with_heatmap(mat) - SliceIt, m, n, Surface(z) - end -end - -# plotting arbitrary shapes/polygons - -@recipe function f(shape::Shape) - seriestype --> :shape - coords(shape) -end - -@recipe function f(shapes::AVec{Shape}) - seriestype --> :shape - coords(shapes) -end - -@recipe function f(shapes::AMat{Shape}) - seriestype --> :shape - for j in axes(shapes, 2) - @series coords(vec(shapes[:, j])) - end -end - - -# -------------------------------------------------------------------- -# 3 arguments -# -------------------------------------------------------------------- - -# images - grays -@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where {T <: Gray} - if is_seriestype_supported(:image) - seriestype := :image - yflip --> true - SliceIt, x, y, Surface(mat) - else - seriestype := :heatmap - yflip --> true - cbar --> false - fillcolor --> ColorGradient([:black, :white]) - SliceIt, x, y, Surface(convert(Matrix{Float64}, mat)) - end -end - -# images - colors -@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where {T <: Colorant} - if is_seriestype_supported(:image) - seriestype := :image - yflip --> true - SliceIt, x, y, Surface(mat) - else - seriestype := :heatmap - yflip --> true - cbar --> false - z, plotattributes[:fillcolor] = replace_image_with_heatmap(mat) - SliceIt, x, y, Surface(z) - end -end - -# -------------------------------------------------------------------- -# Lists of tuples and GeometryTypes.Points -# -------------------------------------------------------------------- -@recipe f(v::AVec{<:GeometryTypes.Point}) = unzip(v) -@recipe f(p::GeometryTypes.Point) = [p] - -# Special case for 4-tuples in :ohlc series -@recipe f(xyuv::AVec{<:Tuple{R1, R2, R3, R4}}) where {R1, R2, R3, R4} = - get(plotattributes, :seriestype, :path) == :ohlc ? OHLC[OHLC(t...) for t in xyuv] : - unzip(xyuv) From 330739298c1c501c2910e5353e54a7ee0fce9960 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Sat, 4 Apr 2020 17:38:38 +0200 Subject: [PATCH 04/17] update and enable precompiles --- src/Plots.jl | 4 +- src/precompile.jl | 989 +++++++++++++++++++++++++--------------------- 2 files changed, 544 insertions(+), 449 deletions(-) diff --git a/src/Plots.jl b/src/Plots.jl index edde93f2..70082e30 100644 --- a/src/Plots.jl +++ b/src/Plots.jl @@ -243,7 +243,7 @@ end const CURRENT_BACKEND = CurrentBackend(:none) -# include("precompile.jl") -# _precompile_() +include("precompile.jl") +_precompile_() end # module diff --git a/src/precompile.jl b/src/precompile.jl index 5e7bc16e..04bf94b5 100644 --- a/src/precompile.jl +++ b/src/precompile.jl @@ -6,6 +6,7 @@ function _precompile_() isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}}) isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{Symbol}}, typeof(Plots.attr!), Plots.Axis}) + isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{typeof(Plots.datetimeformatter)}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Int64, Int64}, Bool}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :ticks), Tuple{Bool, Nothing}}, typeof(Plots.attr!), Plots.Axis}) @@ -36,10 +37,7 @@ function _precompile_() isdefined(Plots, Symbol("#hline!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#hline!##kw")), NamedTuple{(:line,), Tuple{Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}}}, typeof(Plots.hline!), Array{Float64, 2}}) isdefined(Plots, Symbol("#lens!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#lens!##kw")), NamedTuple{(:inset,), Tuple{Tuple{Int64, Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}}}, typeof(Plots.lens!), Array{Int64, 1}, Int}) isdefined(Plots, Symbol("#pie##kw")) && precompile(Tuple{getfield(Plots, Symbol("#pie##kw")), NamedTuple{(:title, :l), Tuple{String, Float64}}, typeof(Plots.pie), Array{String, 1}, Int}) - isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, Plots.PlotText}) isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, String}) - isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, Plots.PlotText}) - isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, String}) isdefined(Plots, Symbol("#portfoliocomposition##kw")) && precompile(Tuple{getfield(Plots, Symbol("#portfoliocomposition##kw")), NamedTuple{(:labels,), Tuple{Array{String, 2}}}, typeof(Plots.portfoliocomposition), Array{Float64, 2}, Int}) isdefined(Plots, Symbol("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), NamedTuple{(:marker, :series_annotations), Tuple{Tuple{Int64, Float64, Symbol}, Array{Any, 1}}}, typeof(Plots.scatter!), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) isdefined(Plots, Symbol("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), NamedTuple{(:markersize, :c), Tuple{Int64, Symbol}}, typeof(Plots.scatter!), Array{Float64, 1}}) @@ -49,19 +47,493 @@ function _precompile_() isdefined(Plots, Symbol("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:marker_z, :color, :legend), Tuple{typeof(Base.:+), Symbol, Bool}}, typeof(Plots.scatter), Array{Float64, 1}, Array{Float64, 1}}) isdefined(Plots, Symbol("#standalone_html##kw")) && precompile(Tuple{getfield(Plots, Symbol("#standalone_html##kw")), NamedTuple{(:title,), Tuple{String}}, typeof(Plots.standalone_html), Plots.Plot{Plots.PlotlyBackend}}) isdefined(Plots, Symbol("#test_examples##kw")) && precompile(Tuple{getfield(Plots, Symbol("#test_examples##kw")), NamedTuple{(:skip,), Tuple{Array{Int64, 1}}}, typeof(Plots.test_examples), Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{Float64, 1}, 1}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{T, 1} where T, 1}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Dates.DateTime, 1}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Function, 1}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Int64, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity), Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, Base.UnitRange{Int64}, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, typeof(identity), Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{String, 1}, Array{Float64, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{String, 1}, Array{String, 1}, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRange{Int64, Int64}, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Array{Float64, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Array{Union{Base.Missing, Float64}, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Base.UnitRange{Int64}, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Nothing, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Nothing}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Function, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Function, 1}, Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipePipeline._extract_group_attributes), Array{String, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._filter_input_data!), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._finish_userrecipe!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData}) + precompile(Tuple{typeof(Plots.RecipePipeline._finish_userrecipe!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData}) + precompile(Tuple{typeof(Plots.RecipePipeline._nobigs), Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._postprocess_axis_args!), Base.Dict{Symbol, Any}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Real, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Union{Base.Missing, Number}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._preprocess_axis_args!), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_fillrange), Int64, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_fillrange), Nothing, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipe), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipe), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Int64, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Nothing, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Tuple{Base.LinRange{Float64}, Base.LinRange{Float64}}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), typeof(identity), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipe), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipe), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipePipeline._scaled_adapted_grid), typeof(identity), Symbol, Symbol, Float64, Float64}) + precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Array{Float64, 1}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Array{T, 1} where T, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Float64, 2}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Function, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Real, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Union{Base.Missing, Int64}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Union{Base.Missing, Number}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), typeof(identity), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline.add_series!), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipePipeline.add_series!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipePipeline.filter_data!), Base.Dict{Symbol, Any}, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.filter_data), Array{Float64, 1}, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.filter_data), Base.OneTo{Int64}, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.filter_data), Nothing, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Array{Symbol, 2}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Plots.Subplot{Plots.GRBackend}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Plots.Subplot{Plots.PlotlyBackend}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Base.Val{:contour}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Base.Val{:heatmap}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Base.Val{:path3d}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Int}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is_axis_attribute), Plots.Plot{Plots.GRBackend}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.is_axis_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.is_seriestype_supported), Plots.Plot{Plots.GRBackend}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.is_seriestype_supported), Plots.Plot{Plots.PlotlyBackend}, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Type{Base.Val{:contour}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Type{Base.Val{:heatmap}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Type{Int}}) + precompile(Tuple{typeof(Plots.RecipePipeline.needs_3d_axes), Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.needs_3d_axes), Type{Base.Val{:path3d}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.needs_3d_axes), Type{Int}}) + precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipePipeline.process_userrecipe!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline.process_userrecipe!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipePipeline.slice_series_attributes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline.slice_series_attributes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{Int64, 1}, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{String, 1}, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{Symbol, 2}, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Plots.GridLayout, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Plots.Plot{Plots.GRBackend}, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, String, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Symbol, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{Int64, 1}, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{String, 1}, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{Symbol, 2}, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Plots.GridLayout, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Plots.Plot{Plots.PlotlyBackend}, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, String, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Symbol, Int64}) + precompile(Tuple{typeof(Plots.RecipePipeline.unzip), Array{Tuple{Array{Float64, 1}, Array{Float64, 1}}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.unzip), Array{Tuple{Float64, Float64, Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Int64, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Int64, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipePipeline.wrap_surfaces!), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.__init__)}) precompile(Tuple{typeof(Plots._add_errorbar_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots._add_markershape), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots._add_smooth_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.Attr}) - precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr}) - precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Any, 1}, Symbol}) - precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{Float64, 1}, 1}, Symbol}) - precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{T, 1} where T, 1}, Symbol}) - precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Function, 1}, Symbol}) - precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Int64, Symbol}) - precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.Surface{Array{Float64, 2}}, Symbol}) - precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity), Symbol}) + precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) precompile(Tuple{typeof(Plots._backend_instance), Symbol}) precompile(Tuple{typeof(Plots._bin_centers), Array{Float64, 1}}) precompile(Tuple{typeof(Plots._binbarlike_baseline), Float64, Symbol}) @@ -98,75 +570,21 @@ function _precompile_() precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Bool}) precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Symbol}) precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.PlotlyBackend}, Bool}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Plots.Spy}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, Plots.Attr, Symbol}) - precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr, Symbol}) - precompile(Tuple{typeof(Plots._filter_input_data!), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Symbol}) + precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Symbol}) precompile(Tuple{typeof(Plots._heatmap_edges), Array{Float64, 1}, Bool}) precompile(Tuple{typeof(Plots._hist_edge), Tuple{Array{Float64, 1}}, Int64, Symbol}) precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64}) precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}}) precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}}, Symbol}) precompile(Tuple{typeof(Plots._initialize_backend), Plots.PlotlyBackend}) - precompile(Tuple{typeof(Plots._override_seriestype_check), Plots.Attr, Symbol}) + precompile(Tuple{typeof(Plots._override_seriestype_check), Plots.RecipePipeline.DefaultsDict, Symbol}) precompile(Tuple{typeof(Plots._pick_default_backend)}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) @@ -194,6 +612,7 @@ function _precompile_() precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) @@ -217,112 +636,24 @@ function _precompile_() precompile(Tuple{typeof(Plots._plot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}}) precompile(Tuple{typeof(Plots._plotly_framestyle), Symbol}) precompile(Tuple{typeof(Plots._plots_defaults)}) - precompile(Tuple{typeof(Plots._postprocess_axis_args!), Base.Dict{Symbol, Any}, Symbol}) - precompile(Tuple{typeof(Plots._prepare_annotations), Plots.Subplot{Plots.GRBackend}, Plots.Attr}) - precompile(Tuple{typeof(Plots._prepare_annotations), Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr}) - precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, Plots.Attr}) - precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.PlotlyBackend}, Plots.Attr}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Plots.Spy}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{}, Array{RecipesBase.RecipeData, 1}}) - precompile(Tuple{typeof(Plots._preprocess_axis_args!), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.Attr, Array{Float64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.Attr, Array{Int64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.Attr, Base.OneTo{Int64}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots._preprocess_binlike), Plots.Attr, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipePipeline.DefaultsDict, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipePipeline.DefaultsDict, Array{Int64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipePipeline.DefaultsDict, Base.OneTo{Int64}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._preprocess_binlike), Plots.RecipePipeline.DefaultsDict, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}) precompile(Tuple{typeof(Plots._preprocess_userrecipe), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._process_plotrecipe), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots._process_plotrecipe), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots._process_seriesrecipe), Plots.Plot{Plots.GRBackend}, Plots.Attr}) - precompile(Tuple{typeof(Plots._process_seriesrecipe), Plots.Plot{Plots.PlotlyBackend}, Plots.Attr}) - precompile(Tuple{typeof(Plots._process_userrecipe), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData}) - precompile(Tuple{typeof(Plots._process_userrecipe), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots._replace_linewidth), Plots.Attr}) + precompile(Tuple{typeof(Plots._replace_linewidth), Plots.RecipePipeline.DefaultsDict}) precompile(Tuple{typeof(Plots._replace_markershape), Array{Symbol, 2}}) precompile(Tuple{typeof(Plots._replace_markershape), Plots.Shape}) precompile(Tuple{typeof(Plots._scale_adjusted_values), Type{Float64}, Array{Float64, 1}, Symbol}) - precompile(Tuple{typeof(Plots._scaled_adapted_grid), typeof(identity), Symbol, Symbol, Float64, Float64}) - precompile(Tuple{typeof(Plots._series_index), Plots.Attr, Plots.Subplot{Plots.GRBackend}}) - precompile(Tuple{typeof(Plots._series_index), Plots.Attr, Plots.Subplot{Plots.PlotlyBackend}}) + precompile(Tuple{typeof(Plots._series_index), Plots.RecipePipeline.DefaultsDict, Plots.Subplot{Plots.GRBackend}}) + precompile(Tuple{typeof(Plots._series_index), Plots.RecipePipeline.DefaultsDict, Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._show), Base.IOStream, Base.Multimedia.MIME{Symbol("image/png")}, Plots.Plot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64}) precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64}) - precompile(Tuple{typeof(Plots._slice_series_args!), Plots.Attr, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64}) - precompile(Tuple{typeof(Plots._slice_series_args!), Plots.Attr, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64}) + precompile(Tuple{typeof(Plots._slice_series_args!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64}) + precompile(Tuple{typeof(Plots._slice_series_args!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64}) precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}}) precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}}) precompile(Tuple{typeof(Plots._transform_ticks), Base.StepRange{Int64, Int64}}) @@ -330,11 +661,11 @@ function _precompile_() precompile(Tuple{typeof(Plots._transform_ticks), Nothing}) precompile(Tuple{typeof(Plots._transform_ticks), Symbol}) precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Base.Dict{Symbol, Any}, Symbol, Int64}) - precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Plots.Attr, Symbol, Int64}) + precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Plots.RecipePipeline.DefaultsDict, Symbol, Int64}) precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64}) - precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.Attr, Symbol, Int64}) + precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Int64}) precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Int64}) - precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr, Symbol, Int64}) + precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Int64}) precompile(Tuple{typeof(Plots._update_axis_colors), Plots.Axis}) precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.GRBackend}, Plots.Axis, Symbol}) precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.PlotlyBackend}, Plots.Axis, Symbol}) @@ -344,29 +675,26 @@ function _precompile_() precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Plots.Attr}) + precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Attr}) - precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.Attr, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}}) - precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.Attr, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}}) + precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}}) + precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Int64, Bool}) - precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.Attr, Int64, Bool}) + precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Int64, Bool}) precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Int64, Bool}) - precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr, Int64, Bool}) + precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Int64, Bool}) precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.GRBackend}, Array{Any, 1}}) precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.PlotlyBackend}, Array{Any, 1}}) precompile(Tuple{typeof(Plots.addExtension), String, String}) precompile(Tuple{typeof(Plots.add_layout_pct!), Base.Dict{Symbol, Any}, Expr, Int64, Int64}) - precompile(Tuple{typeof(Plots.aliasesAndAutopick), Plots.Attr, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64}) - precompile(Tuple{typeof(Plots.all3D), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.all3D), Plots.Attr}) + precompile(Tuple{typeof(Plots.aliasesAndAutopick), Plots.RecipePipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64}) precompile(Tuple{typeof(Plots.allAlphas), Int64}) precompile(Tuple{typeof(Plots.allStyles), Int64}) precompile(Tuple{typeof(Plots.allStyles), Symbol}) precompile(Tuple{typeof(Plots.annotate!), Array{Tuple{Int64, Float64, Plots.PlotText}, 1}}) - precompile(Tuple{typeof(Plots.annotations), Array{Any, 1}}) precompile(Tuple{typeof(Plots.arrow), Int64}) precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol, Symbol}) precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol}) @@ -394,30 +722,14 @@ function _precompile_() precompile(Tuple{typeof(Plots.bottom), Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}) precompile(Tuple{typeof(Plots.bottompad), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.bottompad), Plots.Subplot{Plots.PlotlyBackend}}) - precompile(Tuple{typeof(Plots.build_layout), Plots.Attr}) precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64, Array{Plots.Plot{T} where T<:RecipesBase.AbstractBackend, 1}}) precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64}) + precompile(Tuple{typeof(Plots.build_layout), Plots.RecipePipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.EmptyLayout}) precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.GridLayout}) - precompile(Tuple{typeof(Plots.color_or_nothing!), Plots.Attr, Symbol}) + precompile(Tuple{typeof(Plots.color_or_nothing!), Plots.RecipePipeline.DefaultsDict, Symbol}) precompile(Tuple{typeof(Plots.colorbar_style), Plots.Series}) precompile(Tuple{typeof(Plots.compute_gridsize), Int64, Int64, Int64}) - precompile(Tuple{typeof(Plots.compute_x), Nothing, Plots.Surface{Array{Float64, 2}}, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, typeof(identity), Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Array{String, 1}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRange{Int64, Int64}, Plots.Surface{Array{Float64, 2}}, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Array{Union{Base.Missing, Float64}, 1}, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Base.UnitRange{Int64}, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Nothing, Nothing}) - precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Plots.Surface{Array{Float64, 2}}, Nothing}) precompile(Tuple{typeof(Plots.concatenate_fillrange), Base.UnitRange{Int64}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) precompile(Tuple{typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) precompile(Tuple{typeof(Plots.contour_levels), Plots.Series, Tuple{Float64, Float64}}) @@ -441,7 +753,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Base.Missing}) precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Char}) precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, String}) - precompile(Tuple{typeof(Plots.ensure_gradient!), Plots.Attr, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.ensure_gradient!), Plots.RecipePipeline.DefaultsDict, Symbol, Symbol}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Float64, 1}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Int64, 1}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.OneTo{Int64}}) @@ -450,19 +762,14 @@ function _precompile_() precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.UnitRange{Int64}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Float64}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Int64}) - precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Plots.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Tuple{Float64, Float64}}) - precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, Plots.Attr}) - precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr}) + precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.extend_by_data!), Array{Float64, 1}, Float64}) precompile(Tuple{typeof(Plots.extend_series_data!), Plots.Series, Float64, Symbol}) - precompile(Tuple{typeof(Plots.extractGroupArgs), Array{String, 1}, Array{Float64, 1}}) precompile(Tuple{typeof(Plots.fakedata), Int64, Int64}) - precompile(Tuple{typeof(Plots.fg_color), Plots.Attr}) - precompile(Tuple{typeof(Plots.filter_data!), Base.Dict{Symbol, Any}, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.filter_data), Array{Float64, 1}, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.filter_data), Base.OneTo{Int64}, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.filter_data), Nothing, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.fg_color), Plots.RecipePipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.font), Int64, Int}) precompile(Tuple{typeof(Plots.font), String, Int}) precompile(Tuple{typeof(Plots.font), Symbol, Int}) @@ -498,6 +805,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.get_markerstrokewidth), Plots.Series, Int64}) precompile(Tuple{typeof(Plots.get_minor_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Tuple{Array{Float64, 1}, Array{Any, 1}}}) precompile(Tuple{typeof(Plots.get_minor_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Tuple{Array{Float64, 1}, Array{String, 1}}}) + precompile(Tuple{typeof(Plots.get_minor_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Tuple{Array{Int64, 1}, Array{String, 1}}}) precompile(Tuple{typeof(Plots.get_series_color), ColorTypes.RGBA{Float64}, Plots.Subplot{Plots.GRBackend}, Int64, Symbol}) precompile(Tuple{typeof(Plots.get_series_color), ColorTypes.RGBA{Float64}, Plots.Subplot{Plots.PlotlyBackend}, Int64, Symbol}) precompile(Tuple{typeof(Plots.get_series_color), Int64, Plots.Subplot{Plots.GRBackend}, Int64, Symbol}) @@ -544,6 +852,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.gr_get_color), Plots.Series}) precompile(Tuple{typeof(Plots.gr_get_ticks_size), Tuple{Array{Float64, 1}, Array{Any, 1}}, Int64}) precompile(Tuple{typeof(Plots.gr_get_ticks_size), Tuple{Array{Float64, 1}, Array{String, 1}}, Int64}) + precompile(Tuple{typeof(Plots.gr_get_ticks_size), Tuple{Array{Int64, 1}, Array{String, 1}}, Int64}) precompile(Tuple{typeof(Plots.gr_inqtext), Int64, Int64, String}) precompile(Tuple{typeof(Plots.gr_legend_pos), Plots.Subplot{Plots.GRBackend}, Float64, Float64}) precompile(Tuple{typeof(Plots.gr_polaraxes), Int64, Float64, Plots.Subplot{Plots.GRBackend}}) @@ -587,12 +896,16 @@ function _precompile_() precompile(Tuple{typeof(Plots.hascolorbar), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.hascolorbar), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.hasgrid), Symbol, Symbol}) + precompile(Tuple{typeof(Plots.heatmap), Array{Dates.DateTime, 1}, Int}) precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol, Array{Float64, 1}, Symbol, Tuple{Int64, Int64}}) + precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol, Base.UnitRange{Int64}, Symbol, Tuple{Int64, Int64}}) precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol, Bool}) precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol}) precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol, Tuple{Int64, Int64}}) precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol, Bool}) precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol}) + precompile(Tuple{typeof(Plots.heatmap_edges), Base.UnitRange{Int64}, Symbol, Bool}) + precompile(Tuple{typeof(Plots.heatmap_edges), Base.UnitRange{Int64}, Symbol}) precompile(Tuple{typeof(Plots.ignorenan_extrema), Array{Float64, 1}}) precompile(Tuple{typeof(Plots.ignorenan_extrema), Array{Float64, 2}}) precompile(Tuple{typeof(Plots.ignorenan_extrema), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}) @@ -604,10 +917,6 @@ function _precompile_() precompile(Tuple{typeof(Plots.inline), Plots.Plot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.inline), Plots.Plot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.intersection_point), Float64, Float64, Float64, Float64, Float64, Float64}) - precompile(Tuple{typeof(Plots.is3d), Plots.Attr}) - precompile(Tuple{typeof(Plots.is3d), Plots.Subplot{Plots.GRBackend}}) - precompile(Tuple{typeof(Plots.is3d), Plots.Subplot{Plots.PlotlyBackend}}) - precompile(Tuple{typeof(Plots.is3d), Symbol}) precompile(Tuple{typeof(Plots.is_2tuple), Int64}) precompile(Tuple{typeof(Plots.is_2tuple), Symbol}) precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Array{Float64, 1}, Array{Float64, 1}}}) @@ -639,7 +948,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.isvertical), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.isvertical), Plots.Attr}) + precompile(Tuple{typeof(Plots.isvertical), Plots.RecipePipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}, Int}) precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}}) precompile(Tuple{typeof(Plots.iter_segments), Array{Int64, 1}, Array{Float64, 1}}) @@ -656,8 +965,8 @@ function _precompile_() precompile(Tuple{typeof(Plots.layout_args), Int64, Plots.GridLayout}) precompile(Tuple{typeof(Plots.layout_args), Int64, Tuple{Int64, Int64}}) precompile(Tuple{typeof(Plots.layout_args), Int64}) - precompile(Tuple{typeof(Plots.layout_args), Plots.Attr}) precompile(Tuple{typeof(Plots.layout_args), Plots.GridLayout}) + precompile(Tuple{typeof(Plots.layout_args), Plots.RecipePipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}}) precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}) precompile(Tuple{typeof(Plots.leftpad), Plots.Subplot{Plots.GRBackend}}) @@ -666,7 +975,6 @@ function _precompile_() precompile(Tuple{typeof(Plots.legendfont), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.legendtitlefont), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.like_histogram), Symbol}) - precompile(Tuple{typeof(Plots.like_surface), Symbol}) precompile(Tuple{typeof(Plots.link_axes!), Array{RecipesBase.AbstractLayout, 1}, Symbol}) precompile(Tuple{typeof(Plots.link_axes!), Plots.Axis, Plots.Axis}) precompile(Tuple{typeof(Plots.link_axes!), Plots.GridLayout, Symbol}) @@ -674,7 +982,6 @@ function _precompile_() precompile(Tuple{typeof(Plots.link_axes!), Plots.Subplot{Plots.PlotlyBackend}, Symbol}) precompile(Tuple{typeof(Plots.link_subplots), Array{RecipesBase.AbstractLayout, 1}, Symbol}) precompile(Tuple{typeof(Plots.locate_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText}) - precompile(Tuple{typeof(Plots.locate_annotation), Plots.Subplot{Plots.PlotlyBackend}, Int64, Float64, Plots.PlotText}) precompile(Tuple{typeof(Plots.make_fillrange_from_ribbon), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.make_fillrange_side), Base.UnitRange{Int64}, Array{Float64, 1}}) precompile(Tuple{typeof(Plots.make_fillrange_side), Base.UnitRange{Int64}, Base.LinRange{Float64}}) @@ -685,7 +992,6 @@ function _precompile_() precompile(Tuple{typeof(Plots.make_steps), Base.OneTo{Int64}, Symbol}) precompile(Tuple{typeof(Plots.make_steps), Nothing, Symbol}) precompile(Tuple{typeof(Plots.nanappend!), Array{Float64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.nobigs), Array{Float64, 1}}) precompile(Tuple{typeof(Plots.ohlc), Array{Plots.OHLC{T} where T<:Real, 1}}) precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Base.StepRange{Int64, Int64}}) precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Base.UnitRange{Int64}}) @@ -716,7 +1022,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.StepRange{Int64, Int64}}) precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.UnitRange{Int64}}) precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Nothing}) - precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Plots.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.plotly_domain), Plots.Subplot{Plots.PlotlyBackend}, Symbol}) precompile(Tuple{typeof(Plots.plotly_font), Plots.Font, ColorTypes.RGBA{Float64}}) precompile(Tuple{typeof(Plots.plotly_font), Plots.Font}) @@ -735,7 +1041,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}) precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRange{Int64, Int64}}) precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Plots.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.plotly_polar!), Base.Dict{Symbol, Any}, Plots.Series}) precompile(Tuple{typeof(Plots.plotly_polaraxis), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis}) precompile(Tuple{typeof(Plots.plotly_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Series}) @@ -750,18 +1056,12 @@ function _precompile_() precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.UnitRange{Int64}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}}) precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Nothing, Nothing, Nothing, Tuple{Float64, Float64}}) precompile(Tuple{typeof(Plots.plotly_series_shapes), Plots.Plot{Plots.PlotlyBackend}, Plots.Series, Tuple{Float64, Float64}}) - precompile(Tuple{typeof(Plots.plotly_surface_data), Plots.Series, Plots.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.plotly_surface_data), Plots.Series, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.png), Plots.Plot{Plots.GRBackend}, String}) - precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Real, 1}}) - precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Union{Base.Missing, Number}, 1}}) precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.PlotlyBackend}}) - precompile(Tuple{typeof(Plots.preprocessArgs!), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.preprocessArgs!), Plots.Attr}) + precompile(Tuple{typeof(Plots.preprocess_attributes!), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.preprocess_attributes!), Plots.RecipePipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Bool}) precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Int64}) precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol}) @@ -772,7 +1072,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Float64, Symbol}) precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Int64, Symbol}) precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.processGridArg!), Plots.Attr, Bool, Symbol}) + precompile(Tuple{typeof(Plots.processGridArg!), Plots.RecipePipeline.DefaultsDict, Bool, Symbol}) precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Array{Symbol, 2}}) precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Float64}) precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Int64}) @@ -794,18 +1094,11 @@ function _precompile_() precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, String, Symbol}) precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, Symbol, Symbol}) precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, Tuple{Int64, Int64}, Symbol}) - precompile(Tuple{typeof(Plots.process_fillrange), Int64, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.process_fillrange), Nothing, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.process_ribbon), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.process_ribbon), Int64, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.process_ribbon), Nothing, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.process_ribbon), Tuple{Base.LinRange{Float64}, Base.LinRange{Float64}}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.process_ribbon), typeof(identity), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.recompute_lengths), Array{Measures.Measure, 1}}) precompile(Tuple{typeof(Plots.replaceAlias!), Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Symbol}}) - precompile(Tuple{typeof(Plots.replaceAlias!), Plots.Attr, Symbol, Base.Dict{Symbol, Symbol}}) + precompile(Tuple{typeof(Plots.replaceAlias!), Plots.RecipePipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}}) precompile(Tuple{typeof(Plots.replaceAliases!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Symbol}}) - precompile(Tuple{typeof(Plots.replaceAliases!), Plots.Attr, Base.Dict{Symbol, Symbol}}) + precompile(Tuple{typeof(Plots.replaceAliases!), Plots.RecipePipeline.DefaultsDict, Base.Dict{Symbol, Symbol}}) precompile(Tuple{typeof(Plots.reset_axis_defaults_byletter!)}) precompile(Tuple{typeof(Plots.right), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}}) precompile(Tuple{typeof(Plots.rightpad), Plots.Subplot{Plots.GRBackend}}) @@ -816,22 +1109,13 @@ function _precompile_() precompile(Tuple{typeof(Plots.series_annotations), Plots.SeriesAnnotations}) precompile(Tuple{typeof(Plots.series_annotations_shapes!), Plots.Series, Symbol}) precompile(Tuple{typeof(Plots.series_idx), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.series_vector), Array{Any, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.series_vector), Array{Array{Float64, 1}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.series_vector), Array{Array{T, 1} where T, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.series_vector), Array{Float64, 2}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.series_vector), Array{Function, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.series_vector), Array{Real, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.series_vector), Array{Union{Base.Missing, Int64}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.series_vector), Array{Union{Base.Missing, Number}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.series_vector), typeof(identity), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.shape_data), Plots.Series, Int64}) precompile(Tuple{typeof(Plots.should_add_to_legend), Plots.Series}) precompile(Tuple{typeof(Plots.showaxis), Symbol, Symbol}) precompile(Tuple{typeof(Plots.shrink_by), Float64, Float64, Float64}) precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Int64, Bool}) - precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Plots.Attr, Symbol, Int64, Bool}) - precompile(Tuple{typeof(Plots.slice_arg!), Plots.Attr, Plots.Attr, Symbol, Int64, Bool}) + precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Plots.RecipePipeline.DefaultsDict, Symbol, Int64, Bool}) + precompile(Tuple{typeof(Plots.slice_arg!), Plots.RecipePipeline.DefaultsDict, Plots.RecipePipeline.DefaultsDict, Symbol, Int64, Bool}) precompile(Tuple{typeof(Plots.slice_arg), Array{ColorTypes.RGBA{Float64}, 2}, Int64}) precompile(Tuple{typeof(Plots.slice_arg), Array{Measures.Length{:mm, Float64}, 2}, Int64}) precompile(Tuple{typeof(Plots.slice_arg), Array{String, 2}, Int64}) @@ -849,14 +1133,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.slice_arg), Tuple{Float64, Float64}, Int64}) precompile(Tuple{typeof(Plots.slice_arg), Tuple{Int64, Float64}, Int64}) precompile(Tuple{typeof(Plots.slice_arg), Tuple{Int64, Int64}, Int64}) - precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Array{Int64, 1}, Int64}) - precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Array{String, 1}, Int64}) - precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Array{Symbol, 2}, Int64}) - precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Plots.GridLayout, Int64}) - precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Plots.Plot{Plots.GRBackend}, Int64}) - precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Plots.Plot{Plots.PlotlyBackend}, Int64}) - precompile(Tuple{typeof(Plots.splittable_kw), Symbol, String, Int64}) - precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Symbol, Int64}) + precompile(Tuple{typeof(Plots.slice_arg), typeof(identity), Int64}) precompile(Tuple{typeof(Plots.straightline_data), Plots.Series, Int64}) precompile(Tuple{typeof(Plots.straightline_data), Tuple{Int64, Int64}, Tuple{Float64, Float64}, Array{Float64, 1}, Array{Float64, 1}, Int64}) precompile(Tuple{typeof(Plots.stroke), Int64, Int}) @@ -874,8 +1151,6 @@ function _precompile_() precompile(Tuple{typeof(Plots.text_size), Int64, Int64, Int64}) precompile(Tuple{typeof(Plots.tick_padding), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis}) precompile(Tuple{typeof(Plots.tickfont), Plots.Axis}) - precompile(Tuple{typeof(Plots.ticksType), Tuple{Array{Float64, 1}, Array{Any, 1}}}) - precompile(Tuple{typeof(Plots.ticksType), Tuple{Array{Float64, 1}, Array{String, 1}}}) precompile(Tuple{typeof(Plots.title!), String}) precompile(Tuple{typeof(Plots.title_padding), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.titlefont), Plots.Subplot{Plots.GRBackend}}) @@ -884,9 +1159,6 @@ function _precompile_() precompile(Tuple{typeof(Plots.toppad), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.toppad), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.transpose_z), Plots.Series, Array{Float64, 2}, Bool}) - precompile(Tuple{typeof(Plots.trueOrAllTrue), typeof(Plots.is3d), Symbol}) - precompile(Tuple{typeof(Plots.trueOrAllTrue), typeof(identity), Array{Symbol, 2}}) - precompile(Tuple{typeof(Plots.unzip), Array{Tuple{Float64, Float64, Float64}, 1}}) precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.GridLayout, Array{Measures.Length{:mm, Float64}, 1}}) precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.GridLayout}) precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.Subplot{Plots.GRBackend}, Array{Measures.Length{:mm, Float64}, 1}}) @@ -895,190 +1167,13 @@ function _precompile_() precompile(Tuple{typeof(Plots.update_inset_bboxes!), Plots.Plot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.vline!), Array{Int64, 1}}) precompile(Tuple{typeof(Plots.wand_edges), Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.warnOnUnsupported), Plots.GRBackend, Plots.Attr}) - precompile(Tuple{typeof(Plots.warnOnUnsupported), Plots.PlotlyBackend, Plots.Attr}) - precompile(Tuple{typeof(Plots.warnOnUnsupported_args), Plots.GRBackend, Plots.Attr}) - precompile(Tuple{typeof(Plots.warnOnUnsupported_args), Plots.PlotlyBackend, Plots.Attr}) - precompile(Tuple{typeof(Plots.warnOnUnsupported_scales), Plots.GRBackend, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.warnOnUnsupported_scales), Plots.PlotlyBackend, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Any, 1}, Array{Any, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}, Array{Function, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Int64, 1}, Array{Real, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Any, 1}, Array{Any, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Array{T, 1} where T, 1}, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Function, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Real, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{String, 1}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRange{Int64, Int64}, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Int64, Array{Function, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Int64, typeof(Base.log), Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Array{T, 1} where T, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Int64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Union{Base.Missing, Int64}, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Base.UnitRange{Int64}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Int64, Array{Function, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Int64, typeof(Base.log)}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Nothing, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Plots.GroupBy, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Any, 1}, Array{Any, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}, Array{Function, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Int64, 1}, Array{Real, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Any, 1}, Array{Any, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Array{T, 1} where T, 1}, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Function, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Real, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{String, 1}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRange{Int64, Int64}, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Int64, Array{Function, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Int64, typeof(Base.log), Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Array{T, 1} where T, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Int64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Union{Base.Missing, Int64}, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Base.UnitRange{Int64}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Int64, Array{Function, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Int64, typeof(Base.log)}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Nothing, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Plots.GroupBy, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Type{Int}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Plots.Attr, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Any, 1}, Array{Any, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}, Array{Function, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Int64, 1}, Array{Real, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Any, 1}, Array{Any, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Array{T, 1} where T, 1}, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Function, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Real, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{String, 1}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRange{Int64, Int64}, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Int64, Array{Function, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Int64, typeof(Base.log), Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Array{T, 1} where T, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Float64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Int64, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Union{Base.Missing, Int64}, 1}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Base.UnitRange{Int64}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Int64, Array{Function, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Int64, typeof(Base.log)}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Nothing, Array{Float64, 2}, Nothing}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Plots.GroupBy, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.GRBackend, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.PlotlyBackend, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.GRBackend, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.PlotlyBackend, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported_scales), Plots.GRBackend, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.warn_on_unsupported_scales), Plots.PlotlyBackend, Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.widen), Float64, Float64, Symbol}) - precompile(Tuple{typeof(Plots.wrap_surfaces!), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.wraptuple), Array{Any, 1}}) precompile(Tuple{typeof(Plots.wraptuple), Array{Float64, 1}}) precompile(Tuple{typeof(Plots.wraptuple), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}) From 80ec6f03b4198dfa2991a63fef679f88bdfd1b83 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Sun, 5 Apr 2020 11:58:07 +0200 Subject: [PATCH 05/17] depend on RecipePipeline --- Project.toml | 1 + src/RecipePipeline/RecipePipeline.jl | 97 -------- src/RecipePipeline/api.jl | 142 ------------ src/RecipePipeline/group.jl | 122 ---------- src/RecipePipeline/plot_recipe.jl | 46 ---- src/RecipePipeline/series.jl | 170 -------------- src/RecipePipeline/series_recipe.jl | 62 ----- src/RecipePipeline/type_recipe.jl | 94 -------- src/RecipePipeline/user_recipe.jl | 330 --------------------------- src/RecipePipeline/utils.jl | 220 ------------------ src/pipeline.jl | 2 +- 11 files changed, 2 insertions(+), 1284 deletions(-) delete mode 100644 src/RecipePipeline/RecipePipeline.jl delete mode 100644 src/RecipePipeline/api.jl delete mode 100644 src/RecipePipeline/group.jl delete mode 100644 src/RecipePipeline/plot_recipe.jl delete mode 100644 src/RecipePipeline/series.jl delete mode 100644 src/RecipePipeline/series_recipe.jl delete mode 100644 src/RecipePipeline/type_recipe.jl delete mode 100644 src/RecipePipeline/user_recipe.jl delete mode 100644 src/RecipePipeline/utils.jl diff --git a/Project.toml b/Project.toml index 0f4fb1d8..f6ab3ef4 100644 --- a/Project.toml +++ b/Project.toml @@ -21,6 +21,7 @@ PlotUtils = "995b91a9-d308-5afd-9ec6-746e21dbc043" Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7" REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +RecipePipeline = "01d81517-befc-4cb6-b9ec-a95719d0359c" RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" Reexport = "189a3867-3050-52da-a836-e630ba90ab69" Requires = "ae029012-a4dd-5104-9daa-d747884805df" diff --git a/src/RecipePipeline/RecipePipeline.jl b/src/RecipePipeline/RecipePipeline.jl deleted file mode 100644 index 03cc24e6..00000000 --- a/src/RecipePipeline/RecipePipeline.jl +++ /dev/null @@ -1,97 +0,0 @@ -module RecipePipeline - -import RecipesBase -import RecipesBase: @recipe, @series, RecipeData, is_explicit -import PlotUtils # tryrange and adapted_grid - -export recipe_pipeline! -# Plots relies on these: -export SliceIt, - DefaultsDict, - Formatted, - AbstractSurface, - Surface, - Volume, - is3d, - is_surface, - needs_3d_axes, - group_as_matrix, - reset_kw!, - pop_kw!, - scale_func, - inverse_scale_func, - unzip -# API -export warn_on_recipe_aliases, - splittable_attribute, - split_attribute, - process_userrecipe!, - get_axis_limits, - is_axis_attribute, - type_alias, - plot_setup!, - slice_series_attributes! - -include("api.jl") -include("utils.jl") -include("series.jl") -include("group.jl") -include("user_recipe.jl") -include("type_recipe.jl") -include("plot_recipe.jl") -include("series_recipe.jl") - - -""" - recipe_pipeline!(plt, plotattributes, args) - -Recursively apply user recipes, type recipes, plot recipes and series recipes to build a -list of `Dict`s, each corresponding to a series. At the beginning `plotattributes` -contains only the keyword arguments passed in by the user. Add all series to the plot -bject `plt` and return it. -""" -function recipe_pipeline!(plt, plotattributes, args) - plotattributes[:plot_object] = plt - - # -------------------------------- - # "USER RECIPES" - # -------------------------------- - - # process user and type recipes - kw_list = _process_userrecipes!(plt, plotattributes, args) - - # -------------------------------- - # "PLOT RECIPES" - # -------------------------------- - - # The "Plot recipe" acts like a series type, and is processed before the plot layout - # is created, which allows for setting layouts and other plot-wide attributes. - # We get inputs which have been fully processed by "user recipes" and "type recipes", - # so we can expect standard vectors, surfaces, etc. No defaults have been set yet. - - kw_list = _process_plotrecipes!(plt, kw_list) - - # -------------------------------- - # Plot/Subplot/Layout setup - # -------------------------------- - - plot_setup!(plt, plotattributes, kw_list) - - # At this point, `kw_list` is fully decomposed into individual series... one KW per - # series. The next step is to recursively apply series recipes until the backend - # supports that series type. - - # -------------------------------- - # "SERIES RECIPES" - # -------------------------------- - - _process_seriesrecipes!(plt, kw_list) - - # -------------------------------- - # Return processed plot object - # -------------------------------- - - return plt -end - -end diff --git a/src/RecipePipeline/api.jl b/src/RecipePipeline/api.jl deleted file mode 100644 index feb9350a..00000000 --- a/src/RecipePipeline/api.jl +++ /dev/null @@ -1,142 +0,0 @@ -## Warnings - -""" - warn_on_recipe_aliases!(plt, plotattributes, recipe_type, args...) - -Warn if an alias is dedected in `plotattributes` after a recipe of type `recipe_type` is -applied to 'args'. `recipe_type` is either `:user`, `:type`, `:plot` or `:series`. -""" -function warn_on_recipe_aliases!(plt, plotattributes, recipe_type, args...) end - - -## Grouping - -""" - splittable_attribute(plt, key, val, len) - -Returns `true` if the attribute `key` with the value `val` can be split into groups with -group provided as a vector of length `len`, `false` otherwise. -""" -splittable_attribute(plt, key, val, len) = false -splittable_attribute(plt, key, val::AbstractArray, len) = - !(key in (:group, :color_palette)) && length(axes(val, 1)) == len -splittable_attribute(plt, key, val::Tuple, n) = all(splittable_attribute.(key, val, len)) - - -""" - split_attribute(plt, key, val, indices) - -Select the proper indices from `val` for attribute `key`. -""" -split_attribute(plt, key, val::AbstractArray, indices) = - val[indices, fill(Colon(), ndims(val) - 1)...] -split_attribute(plt, key, val::Tuple, indices) = - Tuple(split_attribute(key, v, indices) for v in val) - - -## Preprocessing attributes - -""" - preprocess_attributes!(plt, plotattributes) - -Any plotting package specific preprocessing of user or recipe input happens here. -For example, Plots replaces aliases and expands magic arguments. -""" -function preprocess_attributes!(plt, plotattributes) end - -# TODO: should the Plots version be defined as fallback in RecipePipeline? -""" - is_subplot_attribute(plt, attr) - -Returns `true` if `attr` is a subplot attribute, otherwise `false`. -""" -is_subplot_attribute(plt, attr) = false - -# TODO: should the Plots version be defined as fallback in RecipePipeline? -""" - is_axis_attribute(plt, attr) - -Returns `true` if `attr` is an axis attribute, i.e. it applies to `xattr`, `yattr` and -`zattr`, otherwise `false`. -""" -is_axis_attribute(plt, attr) = false - - -## User recipes - -""" - process_userrecipe!(plt, attributes_list, attributes) - -Do plotting package specific post-processing and add series attributes to attributes_list. -For example, Plots increases the number of series in `plt`, sets `:series_plotindex` in -attributes and possible adds new series attributes for errorbars or smooth. -""" -function process_userrecipe!(plt, attributes_list, attributes) - push!(attributes_list, attributes) -end - -""" - get_axis_limits(plt, letter) - -Get the limits for the axis specified by `letter` (`:x`, `:y` or `:z`) in `plt`. If it -errors, `tryrange` from PlotUtils is used. -""" -get_axis_limits(plt, letter) = ErrorException("Axis limits not defined.") - - -## Plot recipes - -""" - type_alias(plt, st) - -Return the seriestype alias for `st`. -""" -type_alias(plt, st) = st - - -## Plot setup - -""" - plot_setup!(plt, plotattributes, kw_list) - -Setup plot, subplots and layouts. -For example, Plots creates the backend figure, initializes subplots, expands extrema and -links subplot axes. -""" -function plot_setup!(plt, plotattributes, kw_list) end - - -## Series recipes - -""" - slice_series_attributes!(plt, kw_list, kw) - -For attributes given as vector with one element per series, only select the value for -current series. -""" -function slice_series_attributes!(plt, kw_list, kw) end - - -""" - series_defaults(plt) - -Returns a `Dict` storing the defaults for series attributes. -""" -series_defaults(plt) = Dict{Symbol, Any}() - -# TODO: Add a more sensible fallback including e.g. path, scatter, ... -""" - is_seriestype_supported(plt, st) - -Check if the plotting package natively supports the seriestype `st`. -""" -is_seriestype_supported(plt, st) = false - -""" - add_series!(plt, kw) - -Adds the series defined by `kw` to the plot object. -For example Plots updates the current subplot arguments, expands extrema and pushes the -the series to the series_list of `plt`. -""" -function add_series!(plt, kw) end diff --git a/src/RecipePipeline/group.jl b/src/RecipePipeline/group.jl deleted file mode 100644 index ca9d46c5..00000000 --- a/src/RecipePipeline/group.jl +++ /dev/null @@ -1,122 +0,0 @@ -"A special type that will break up incoming data into groups, and allow for easier creation of grouped plots" -mutable struct GroupBy - group_labels::Vector # length == numGroups - group_indices::Vector{Vector{Int}} # list of indices for each group -end - -# this is when given a vector-type of values to group by -function _extract_group_attributes(v::AVec, args...; legend_entry = string) - group_labels = sort(collect(unique(v))) - n = length(group_labels) - if n > 100 - @warn("You created n=$n groups... Is that intended?") - end - group_indices = Vector{Int}[filter(i -> v[i] == glab, eachindex(v)) for glab in group_labels] - GroupBy(map(legend_entry, group_labels), group_indices) -end - -legend_entry_from_tuple(ns::Tuple) = join(ns, ' ') - -# this is when given a tuple of vectors of values to group by -function _extract_group_attributes(vs::Tuple, args...) - isempty(vs) && return GroupBy([""], [axes(args[1],1)]) - v = map(tuple, vs...) - _extract_group_attributes(v, args...; legend_entry = legend_entry_from_tuple) -end - -# allow passing NamedTuples for a named legend entry -legend_entry_from_tuple(ns::NamedTuple) = - join(["$k = $v" for (k, v) in pairs(ns)], ", ") - -function _extract_group_attributes(vs::NamedTuple, args...) - isempty(vs) && return GroupBy([""], [axes(args[1],1)]) - v = map(NamedTuple{keys(vs)}∘tuple, values(vs)...) - _extract_group_attributes(v, args...; legend_entry = legend_entry_from_tuple) -end - -# expecting a mapping of "group label" to "group indices" -function _extract_group_attributes(idxmap::Dict{T,V}, args...) where {T, V<:AVec{Int}} - group_labels = sortedkeys(idxmap) - group_indices = Vector{Int}[collect(idxmap[k]) for k in group_labels] - GroupBy(group_labels, group_indices) -end - -filter_data(v::AVec, idxfilter::AVec{Int}) = v[idxfilter] -filter_data(v, idxfilter) = v - -function filter_data!(plotattributes::AKW, idxfilter) - for s in (:x, :y, :z) - plotattributes[s] = filter_data(get(plotattributes, s, nothing), idxfilter) - end -end - -function _filter_input_data!(plotattributes::AKW) - idxfilter = pop!(plotattributes, :idxfilter, nothing) - if idxfilter !== nothing - filter_data!(plotattributes, idxfilter) - end -end - -function groupedvec2mat(x_ind, x, y::AbstractArray, groupby, def_val = y[1]) - y_mat = Array{promote_type(eltype(y), typeof(def_val))}( - undef, - length(keys(x_ind)), - length(groupby.group_labels), - ) - fill!(y_mat, def_val) - for i in eachindex(groupby.group_labels) - xi = x[groupby.group_indices[i]] - yi = y[groupby.group_indices[i]] - y_mat[getindex.(Ref(x_ind), xi), i] = yi - end - return y_mat -end - -groupedvec2mat(x_ind, x, y::Tuple, groupby) = - Tuple(groupedvec2mat(x_ind, x, v, groupby) for v in y) - -group_as_matrix(t) = false - -# split the group into 1 series per group, and set the label and idxfilter for each -@recipe function f(groupby::GroupBy, args...) - plt = plotattributes[:plot_object] - group_length = maximum(union(groupby.group_indices...)) - if !(group_as_matrix(args[1])) - for (i, glab) in enumerate(groupby.group_labels) - @series begin - label --> string(glab) - idxfilter --> groupby.group_indices[i] - for (key, val) in plotattributes - if splittable_attribute(plt, key, val, group_length) - :($key) := split_attribute(plt, key, val, groupby.group_indices[i]) - end - end - args - end - end - else - g = args[1] - if length(g.args) == 1 - x = zeros(Int, group_length) - for indexes in groupby.group_indices - x[indexes] = eachindex(indexes) - end - last_args = g.args - else - x = g.args[1] - last_args = g.args[2:end] - end - x_u = unique(sort(x)) - x_ind = Dict(zip(x_u, eachindex(x_u))) - for (key, val) in plotattributes - if splittable_kw(key, val, group_length) - :($key) := groupedvec2mat(x_ind, x, val, groupby) - end - end - label --> reshape(groupby.group_labels, 1, :) - typeof(g)(( - x_u, - (groupedvec2mat(x_ind, x, arg, groupby, NaN) for arg in last_args)..., - )) - end -end diff --git a/src/RecipePipeline/plot_recipe.jl b/src/RecipePipeline/plot_recipe.jl deleted file mode 100644 index 6b7e05c3..00000000 --- a/src/RecipePipeline/plot_recipe.jl +++ /dev/null @@ -1,46 +0,0 @@ -""" - _process_plotrecipes!(plt, kw_list) - -Grab the first in line to be processed and pass it through `apply_recipe` to generate a -list of `RecipeData` objects. -If we applied a "plot recipe" without error, then add the returned datalist's KWs, -otherwise we just add the original KW. -""" -function _process_plotrecipes!(plt, kw_list) - still_to_process = kw_list - kw_list = KW[] - while !isempty(still_to_process) - next_kw = popfirst!(still_to_process) - _process_plotrecipe(plt, next_kw, kw_list, still_to_process) - end - return kw_list -end - - -function _process_plotrecipe(plt, kw, kw_list, still_to_process) - if !isa(get(kw, :seriestype, nothing), Symbol) - # seriestype was never set, or it's not a Symbol, so it can't be a plot recipe - push!(kw_list, kw) - return - end - try - st = kw[:seriestype] - st = kw[:seriestype] = type_alias(plt, st) - datalist = RecipesBase.apply_recipe(kw, Val{st}, plt) - warn_on_recipe_aliases!(plt, datalist, :plot, st) - for data in datalist - preprocess_attributes!(plt, data.plotattributes) - if data.plotattributes[:seriestype] == st - error("Plot recipe $st returned the same seriestype: $(data.plotattributes)") - end - push!(still_to_process, data.plotattributes) - end - catch err - if isa(err, MethodError) - push!(kw_list, kw) - else - rethrow() - end - end - return -end diff --git a/src/RecipePipeline/series.jl b/src/RecipePipeline/series.jl deleted file mode 100644 index e967fa4c..00000000 --- a/src/RecipePipeline/series.jl +++ /dev/null @@ -1,170 +0,0 @@ -const FuncOrFuncs{F} = Union{F, Vector{F}, Matrix{F}} -const MaybeNumber = Union{Number, Missing} -const MaybeString = Union{AbstractString, Missing} -const DataPoint = Union{MaybeNumber, MaybeString} - -_prepare_series_data(x) = error("Cannot convert $(typeof(x)) to series data for plotting") -_prepare_series_data(::Nothing) = nothing -_prepare_series_data(t::Tuple{T, T}) where {T <: Number} = t -_prepare_series_data(f::Function) = f -_prepare_series_data(ar::AbstractRange{<:Number}) = ar -function _prepare_series_data(a::AbstractArray{<:MaybeNumber}) - f = isimmutable(a) ? replace : replace! - a = f(x -> ismissing(x) || isinf(x) ? NaN : x, map(float, a)) -end -_prepare_series_data(a::AbstractArray{<:Missing}) = fill(NaN, axes(a)) -_prepare_series_data(a::AbstractArray{<:MaybeString}) = - replace(x -> ismissing(x) ? "" : x, a) -_prepare_series_data(s::Surface{<:AMat{<:MaybeNumber}}) = - Surface(_prepare_series_data(s.surf)) -_prepare_series_data(s::Surface) = s # non-numeric Surface, such as an image -_prepare_series_data(v::Volume) = - Volume(_prepare_series_data(v.v), v.x_extents, v.y_extents, v.z_extents) - -# default: assume x represents a single series -_series_data_vector(x, plotattributes) = [_prepare_series_data(x)] - -# fixed number of blank series -_series_data_vector(n::Integer, plotattributes) = [zeros(0) for i in 1:n] - -# vector of data points is a single series -_series_data_vector(v::AVec{<:DataPoint}, plotattributes) = [_prepare_series_data(v)] - -# list of things (maybe other vectors, functions, or something else) -function _series_data_vector(v::AVec, plotattributes) - if all(x -> x isa MaybeNumber, v) - _series_data_vector(Vector{MaybeNumber}(v), plotattributes) - elseif all(x -> x isa MaybeString, v) - _series_data_vector(Vector{MaybeString}(v), plotattributes) - else - vcat((_series_data_vector(vi, plotattributes) for vi in v)...) - end -end - -# Matrix is split into columns -function _series_data_vector(v::AMat{<:DataPoint}, plotattributes) - if is3d(plotattributes) - [_prepare_series_data(Surface(v))] - else - [_prepare_series_data(v[:, i]) for i in axes(v, 2)] - end -end - -# -------------------------------------------------------------------- -# Fillranges & ribbons - - -_process_fillrange(range::Number, plotattributes) = [range] -_process_fillrange(range, plotattributes) = _series_data_vector(range, plotattributes) - -_process_ribbon(ribbon::Number, plotattributes) = [ribbon] -_process_ribbon(ribbon, plotattributes) = _series_data_vector(ribbon, plotattributes) -# ribbon as a tuple: (lower_ribbons, upper_ribbons) -_process_ribbon(ribbon::Tuple{S, T}, plotattributes) where {S, T} = collect(zip( - _series_data_vector(ribbon[1], plotattributes), - _series_data_vector(ribbon[2], plotattributes), -)) - - -# -------------------------------------------------------------------- - -_compute_x(x::Nothing, y::Nothing, z) = axes(z, 1) -_compute_x(x::Nothing, y, z) = axes(y, 1) -_compute_x(x::Function, y, z) = map(x, y) -_compute_x(x, y, z) = x - -_compute_y(x::Nothing, y::Nothing, z) = axes(z, 2) -_compute_y(x, y::Function, z) = map(y, x) -_compute_y(x, y, z) = y - -_compute_z(x, y, z::Function) = map(z, x, y) -_compute_z(x, y, z::AbstractMatrix) = Surface(z) -_compute_z(x, y, z::Nothing) = nothing -_compute_z(x, y, z) = z - -_nobigs(v::AVec{BigFloat}) = map(Float64, v) -_nobigs(v::AVec{BigInt}) = map(Int64, v) -_nobigs(v) = v - -@noinline function _compute_xyz(x, y, z) - x = _compute_x(x, y, z) - y = _compute_y(x, y, z) - z = _compute_z(x, y, z) - _nobigs(x), _nobigs(y), _nobigs(z) -end - -# not allowed -_compute_xyz(x::Nothing, y::FuncOrFuncs{F}, z) where {F <: Function} = - error("If you want to plot the function `$y`, you need to define the x values!") -_compute_xyz(x::Nothing, y::Nothing, z::FuncOrFuncs{F}) where {F <: Function} = - error("If you want to plot the function `$z`, you need to define x and y values!") -_compute_xyz(x::Nothing, y::Nothing, z::Nothing) = error("x/y/z are all nothing!") - -# -------------------------------------------------------------------- - - -# we are going to build recipes to do the processing and splitting of the args - -# -------------------------------------------------------------------- -# The catch-all SliceIt recipe -# -------------------------------------------------------------------- - -# ensure we dispatch to the slicer -struct SliceIt end - -# TODO: Should ribbon and fillrange be handled by the plotting package? - -# The `SliceIt` recipe finishes user and type recipe processing. -# It splits processed data into individual series data, stores in copied `plotattributes` -# for each series and returns no arguments. -@recipe function f(::Type{SliceIt}, x, y, z) - - # handle data with formatting attached - if typeof(x) <: Formatted - xformatter := x.formatter - x = x.data - end - if typeof(y) <: Formatted - yformatter := y.formatter - y = y.data - end - if typeof(z) <: Formatted - zformatter := z.formatter - z = z.data - end - - xs = _series_data_vector(x, plotattributes) - ys = _series_data_vector(y, plotattributes) - zs = _series_data_vector(z, plotattributes) - - fr = pop!(plotattributes, :fillrange, nothing) - fillranges = _process_fillrange(fr, plotattributes) - mf = length(fillranges) - - rib = pop!(plotattributes, :ribbon, nothing) - ribbons = _process_ribbon(rib, plotattributes) - mr = length(ribbons) - - mx = length(xs) - my = length(ys) - mz = length(zs) - if mx > 0 && my > 0 && mz > 0 - for i in 1:max(mx, my, mz) - # add a new series - di = copy(plotattributes) - xi, yi, zi = xs[mod1(i, mx)], ys[mod1(i, my)], zs[mod1(i, mz)] - di[:x], di[:y], di[:z] = _compute_xyz(xi, yi, zi) - - # handle fillrange - fr = fillranges[mod1(i, mf)] - di[:fillrange] = isa(fr, Function) ? map(fr, di[:x]) : fr - - # handle ribbons - rib = ribbons[mod1(i, mr)] - di[:ribbon] = isa(rib, Function) ? map(rib, di[:x]) : rib - - push!(series_list, RecipeData(di, ())) - end - end - nothing # don't add a series for the main block -end diff --git a/src/RecipePipeline/series_recipe.jl b/src/RecipePipeline/series_recipe.jl deleted file mode 100644 index 37bb6a4c..00000000 --- a/src/RecipePipeline/series_recipe.jl +++ /dev/null @@ -1,62 +0,0 @@ -""" - _process_seriesrecipes!(plt, kw_list) - -Recursively apply series recipes until the backend supports the seriestype -""" -function _process_seriesrecipes!(plt, kw_list) - for kw in kw_list - # in series attributes given as vector with one element per series, - # select the value for current series - slice_series_attributes!(plt, kw_list, kw) - - series_attr = DefaultsDict(kw, series_defaults(plt)) - # now we have a fully specified series, with colors chosen. we must recursively - # handle series recipes, which dispatch on seriestype. If a backend does not - # natively support a seriestype, we check for a recipe that will convert that - # series type into one made up of lower-level components. - # For example, a histogram is just a bar plot with binned data, a bar plot is - # really a filled step plot, and a step plot is really just a path. So any backend - # that supports drawing a path will implicitly be able to support step, bar, and - # histogram plots (and any recipes that use those components). - _process_seriesrecipe(plt, series_attr) - end -end - -# this method recursively applies series recipes when the seriestype is not supported -# natively by the backend -function _process_seriesrecipe(plt, plotattributes) - # replace seriestype aliases - st = Symbol(plotattributes[:seriestype]) - st = plotattributes[:seriestype] = type_alias(plt, st) - - # shapes shouldn't have fillrange set - if plotattributes[:seriestype] == :shape - plotattributes[:fillrange] = nothing - end - - # if it's natively supported, finalize processing and pass along to the backend, - # otherwise recurse - if is_seriestype_supported(plt, st) - add_series!(plt, plotattributes) - else - # get a sub list of series for this seriestype - x, y, z = plotattributes[:x], plotattributes[:y], plotattributes[:z] - datalist = RecipesBase.apply_recipe(plotattributes, Val{st}, x, y, z) - warn_on_recipe_aliases!(plt, datalist, :series, st) - - # assuming there was no error, recursively apply the series recipes - for data in datalist - if isa(data, RecipeData) - preprocess_attributes!(plt, data.plotattributes) - if data.plotattributes[:seriestype] == st - error("The seriestype didn't change in series recipe $st. This will cause a StackOverflow.") - end - _process_seriesrecipe(plt, data.plotattributes) - else - @warn("Unhandled recipe: $(data)") - break - end - end - end - nothing -end diff --git a/src/RecipePipeline/type_recipe.jl b/src/RecipePipeline/type_recipe.jl deleted file mode 100644 index 527fbae6..00000000 --- a/src/RecipePipeline/type_recipe.jl +++ /dev/null @@ -1,94 +0,0 @@ -# this is the default "type recipe"... just pass the object through -@recipe f(::Type{T}, v::T) where {T} = v - -# this should catch unhandled "series recipes" and error with a nice message -@recipe f(::Type{V}, x, y, z) where {V <: Val} = - error("The backend must not support the series type $V, and there isn't a series recipe defined.") - -""" - _apply_type_recipe(plotattributes, v::T, letter) - -Apply the type recipe with signature `(::Type{T}, ::T)`. -""" -function _apply_type_recipe(plotattributes, v, letter) - _preprocess_axis_args!(plotattributes, letter) - rdvec = RecipesBase.apply_recipe(plotattributes, typeof(v), v) - warn_on_recipe_aliases!(plotattributes[:plot_object], plotattributes, :type, typeof(v)) - _postprocess_axis_args!(plotattributes, letter) - return rdvec[1].args[1] -end - -# Handle type recipes when the recipe is defined on the elements. -# This sort of recipe should return a pair of functions... one to convert to number, -# and one to format tick values. -function _apply_type_recipe(plotattributes, v::AbstractArray, letter) - plt = plotattributes[:plot_object] - _preprocess_axis_args!(plotattributes, letter) - # First we try to apply an array type recipe. - w = RecipesBase.apply_recipe(plotattributes, typeof(v), v)[1].args[1] - warn_on_recipe_aliases!(plt, plotattributes, :type, typeof(v)) - # If the type did not change try it element-wise - if typeof(v) == typeof(w) - isempty(skipmissing(v)) && return Float64[] - x = first(skipmissing(v)) - args = RecipesBase.apply_recipe(plotattributes, typeof(x), x)[1].args - warn_on_recipe_aliases!(plt, plotattributes, :type, typeof(x)) - _postprocess_axis_args!(plotattributes, letter) - if length(args) == 2 && all(arg -> arg isa Function, args) - numfunc, formatter = args - return Formatted(map(numfunc, v), formatter) - else - return v - end - end - _postprocess_axis_args!(plotattributes, letter) - return w -end - -# special handling for Surface... need to properly unwrap and re-wrap -_apply_type_recipe(plotattributes, v::Surface{<:AMat{<:DataPoint}}) = v -function _apply_type_recipe(plotattributes, v::Surface) - ret = _apply_type_recipe(plotattributes, v.surf) - if typeof(ret) <: Formatted - Formatted(Surface(ret.data), ret.formatter) - else - Surface(ret.data) - end -end - -# don't do anything for datapoints or nothing -_apply_type_recipe(plotattributes, v::AbstractArray{<:DataPoint}, letter) = v -_apply_type_recipe(plotattributes, v::Nothing, letter) = v - -# axis args before type recipes should still be mapped to all axes -function _preprocess_axis_args!(plotattributes) - plt = plotattributes[:plot_object] - for (k, v) in plotattributes - if is_axis_attribute(plt, k) - pop!(plotattributes, k) - for l in (:x, :y, :z) - lk = Symbol(l, k) - haskey(plotattributes, lk) || (plotattributes[lk] = v) - end - end - end -end -function _preprocess_axis_args!(plotattributes, letter) - plotattributes[:letter] = letter - _preprocess_axis_args!(plotattributes) -end - -# axis args in type recipes should only be applied to the current axis -function _postprocess_axis_args!(plotattributes, letter) - plt = plotattributes[:plot_object] - pop!(plotattributes, :letter) - if letter in (:x, :y, :z) - for (k, v) in plotattributes - if is_axis_attribute(plt, k) - pop!(plotattributes, k) - lk = Symbol(letter, k) - haskey(plotattributes, lk) || (plotattributes[lk] = v) - end - end - end -end diff --git a/src/RecipePipeline/user_recipe.jl b/src/RecipePipeline/user_recipe.jl deleted file mode 100644 index 0023474f..00000000 --- a/src/RecipePipeline/user_recipe.jl +++ /dev/null @@ -1,330 +0,0 @@ -""" - _process_userrecipes(plt, plotattributes, args) - -Wrap input arguments in a `RecipeData' vector and recursively apply user recipes and type -recipes on the first element. Prepend the returned `RecipeData` vector. If an element with -empy `args` is returned pop it from the vector, finish up, and it to vector of `Dict`s with -processed series. When all arguments are processed return the series `Dict`. -""" -function _process_userrecipes!(plt, plotattributes, args) - still_to_process = _recipedata_vector(plt, plotattributes, args) - - # for plotting recipes, swap out the args and update the parameter dictionary - # we are keeping a stack of series that still need to be processed. - # each pass through the loop, we pop one off and apply the recipe. - # the recipe will return a list a Series objects... the ones that are - # finished (no more args) get added to the kw_list, the ones that are not - # are placed on top of the stack and are then processed further. - kw_list = KW[] - while !isempty(still_to_process) - # grab the first in line to be processed and either add it to the kw_list or - # pass it through apply_recipe to generate a list of RecipeData objects - # (data + attributes) for further processing. - next_series = popfirst!(still_to_process) - # recipedata should be of type RecipeData. - # if it's not then the inputs must not have been fully processed by recipes - if !(typeof(next_series) <: RecipeData) - error("Inputs couldn't be processed... expected RecipeData but got: $next_series") - end - if isempty(next_series.args) - _finish_userrecipe!(plt, kw_list, next_series) - else - rd_list = - RecipesBase.apply_recipe(next_series.plotattributes, next_series.args...) - warn_on_recipe_aliases!(plt, rd_list, :user, next_series.args...) - prepend!(still_to_process, rd_list) - end - end - - # don't allow something else to handle it - plotattributes[:smooth] = false - kw_list -end - - -# TODO Move this to api.jl? - -function _recipedata_vector(plt, plotattributes, args) - still_to_process = RecipeData[] - # the grouping mechanism is a recipe on a GroupBy object - # we simply add the GroupBy object to the front of the args list to allow - # the recipe to be applied - if haskey(plotattributes, :group) - args = (_extract_group_attributes(plotattributes[:group], args...), args...) - end - - # if we were passed a vector/matrix of seriestypes and there's more than one row, - # we want to duplicate the inputs, once for each seriestype row. - if !isempty(args) - append!(still_to_process, _expand_seriestype_array(plotattributes, args)) - end - - # remove subplot and axis args from plotattributes... - # they will be passed through in the kw_list - if !isempty(args) - for (k, v) in plotattributes - if is_subplot_attribute(plt, k) || is_axis_attribute(plt, k) - reset_kw!(plotattributes, k) - end - end - end - - still_to_process -end - -function _expand_seriestype_array(plotattributes, args) - sts = get(plotattributes, :seriestype, :path) - if typeof(sts) <: AbstractArray - reset_kw!(plotattributes, :seriestype) - rd = Vector{RecipeData}(undef, size(sts, 1)) - for r in axes(sts, 1) - dc = copy(plotattributes) - dc[:seriestype] = sts[r:r, :] - rd[r] = RecipeData(dc, args) - end - rd - else - RecipeData[RecipeData(copy(plotattributes), args)] - end -end - - -function _finish_userrecipe!(plt, kw_list, recipedata) - # when the arg tuple is empty, that means there's nothing left to recursively - # process... finish up and add to the kw_list - kw = recipedata.plotattributes - preprocess_attributes!(plt, kw) - # if there was a grouping, filter the data here - _filter_input_data!(kw) - process_userrecipe!(plt, kw_list, kw) -end - - -# -------------------------------- -# Fallback user recipes -# -------------------------------- - -# These call `_apply_type_recipe` in type_recipe.jl and finally the `SliceIt` recipe in -# series.jl. - -# handle "type recipes" by converting inputs, and then either re-calling or slicing -@recipe function f(x, y, z) - wrap_surfaces!(plotattributes, x, y, z) - did_replace = false - newx = _apply_type_recipe(plotattributes, x, :x) - x === newx || (did_replace = true) - newy = _apply_type_recipe(plotattributes, y, :y) - y === newy || (did_replace = true) - newz = _apply_type_recipe(plotattributes, z, :z) - z === newz || (did_replace = true) - if did_replace - newx, newy, newz - else - SliceIt, x, y, z - end -end -@recipe function f(x, y) - wrap_surfaces!(plotattributes, x, y) - did_replace = false - newx = _apply_type_recipe(plotattributes, x, :x) - x === newx || (did_replace = true) - newy = _apply_type_recipe(plotattributes, y, :y) - y === newy || (did_replace = true) - if did_replace - newx, newy - else - SliceIt, x, y, nothing - end -end -@recipe function f(y) - wrap_surfaces!(plotattributes, y) - newy = _apply_type_recipe(plotattributes, y, :y) - if y !== newy - newy - else - SliceIt, nothing, y, nothing - end -end - -# if there's more than 3 inputs, it can't be passed directly to SliceIt -# so we'll apply_type_recipe to all of them -@recipe function f(v1, v2, v3, v4, vrest...) - did_replace = false - newargs = map( - v -> begin - newv = _apply_type_recipe(plotattributes, v, :unknown) - if newv !== v - did_replace = true - end - newv - end, - (v1, v2, v3, v4, vrest...), - ) - if !did_replace - error("Couldn't process recipe args: $(map(typeof, (v1, v2, v3, v4, vrest...)))") - end - newargs -end - - -# helper function to ensure relevant attributes are wrapped by Surface -function wrap_surfaces!(plotattributes, args...) end -wrap_surfaces!(plotattributes, x::AMat, y::AMat, z::AMat) = wrap_surfaces!(plotattributes) -wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::AMat) = wrap_surfaces!(plotattributes) -function wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::Surface) - wrap_surfaces!(plotattributes) -end -function wrap_surfaces!(plotattributes) - if haskey(plotattributes, :fill_z) - v = plotattributes[:fill_z] - if !isa(v, Surface) - plotattributes[:fill_z] = Surface(v) - end - end -end - - -# -------------------------------- -# Special Cases -# -------------------------------- - -# -------------------------------- -# 1 argument - -@recipe function f(n::Integer) - if is3d(plotattributes) - SliceIt, n, n, n - else - SliceIt, n, n, nothing - end -end - -# return a surface if this is a 3d plot, otherwise let it be sliced up -@recipe function f(mat::AMat) - if is3d(plotattributes) - n, m = axes(mat) - m, n, Surface(mat) - else - nothing, mat, nothing - end -end - -# if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface -@recipe function f(fmt::Formatted{<:AMat}) - if is3d(plotattributes) - mat = fmt.data - n, m = axes(mat) - m, n, Formatted(Surface(mat), fmt.formatter) - else - nothing, fmt, nothing - end -end - -# assume this is a Volume, so construct one -@recipe function f(vol::AbstractArray{<:MaybeNumber, 3}, args...) - seriestype := :volume - SliceIt, nothing, Volume(vol, args...), nothing -end - -# Dicts: each entry is a data point (x,y)=(key,value) -@recipe f(d::AbstractDict) = collect(keys(d)), collect(values(d)) - -# function without range... use the current range of the x-axis -@recipe function f(f::FuncOrFuncs{F}) where {F <: Function} - plt = plotattributes[:plot_object] - xmin, xmax = if haskey(plotattributes, :xlims) - plotattributes[:xlims] - else - try - get_axis_limits(plt, :x) - catch - xinv = inverse_scale_func(get(plotattributes, :xscale, :identity)) - xm = PlotUtils.tryrange(f, xinv.([-5, -1, 0, 0.01])) - xm, PlotUtils.tryrange(f, filter(x -> x > xm, xinv.([5, 1, 0.99, 0, -0.01]))) - end - end - f, xmin, xmax -end - - -# -------------------------------- -# 2 arguments - -# if functions come first, just swap the order (not to be confused with parametric -# functions... as there would be more than one function passed in) -@recipe function f(f::FuncOrFuncs{F}, x) where {F <: Function} - F2 = typeof(x) - @assert !(F2 <: Function || (F2 <: AbstractArray && F2.parameters[1] <: Function)) - # otherwise we'd hit infinite recursion here - x, f -end - - -# -------------------------------- -# 3 arguments - -# surface-like... function -@recipe function f(x::AVec, y::AVec, zf::Function) - x, y, Surface(zf, x, y) # TODO: replace with SurfaceFunction when supported -end - -# surface-like... matrix grid -@recipe function f(x::AVec, y::AVec, z::AMat) - if !is_surface(plotattributes) - plotattributes[:seriestype] = :contour - end - x, y, Surface(z) -end - -# parametric functions -# special handling... xmin/xmax with parametric function(s) -@recipe function f(f::Function, xmin::Number, xmax::Number) - xscale, yscale = [get(plotattributes, sym, :identity) for sym in (:xscale, :yscale)] - _scaled_adapted_grid(f, xscale, yscale, xmin, xmax) -end -@recipe function f(fs::AbstractArray{F}, xmin::Number, xmax::Number) where {F <: Function} - xscale, yscale = [get(plotattributes, sym, :identity) for sym in (:xscale, :yscale)] - unzip(_scaled_adapted_grid.(fs, xscale, yscale, xmin, xmax)) -end -@recipe f( - fx::FuncOrFuncs{F}, - fy::FuncOrFuncs{G}, - u::AVec, -) where {F <: Function, G <: Function} = _map_funcs(fx, u), _map_funcs(fy, u) -@recipe f( - fx::FuncOrFuncs{F}, - fy::FuncOrFuncs{G}, - umin::Number, - umax::Number, - n = 200, -) where {F <: Function, G <: Function} = fx, fy, range(umin, stop = umax, length = n) - -function _scaled_adapted_grid(f, xscale, yscale, xmin, xmax) - (xf, xinv), (yf, yinv) = ((scale_func(s), inverse_scale_func(s)) for s in (xscale, yscale)) - xs, ys = PlotUtils.adapted_grid(yf ∘ f ∘ xinv, xf.((xmin, xmax))) - xinv.(xs), yinv.(ys) -end - -# special handling... 3D parametric function(s) -@recipe function f( - fx::FuncOrFuncs{F}, - fy::FuncOrFuncs{G}, - fz::FuncOrFuncs{H}, - u::AVec, -) where {F <: Function, G <: Function, H <: Function} - _map_funcs(fx, u), _map_funcs(fy, u), _map_funcs(fz, u) -end -@recipe function f( - fx::FuncOrFuncs{F}, - fy::FuncOrFuncs{G}, - fz::FuncOrFuncs{H}, - umin::Number, - umax::Number, - numPoints = 200, -) where {F <: Function, G <: Function, H <: Function} - fx, fy, fz, range(umin, stop = umax, length = numPoints) -end - -# list of tuples -@recipe f(v::AVec{<:Tuple}) = unzip(v) -@recipe f(tup::Tuple) = [tup] diff --git a/src/RecipePipeline/utils.jl b/src/RecipePipeline/utils.jl deleted file mode 100644 index 54862d47..00000000 --- a/src/RecipePipeline/utils.jl +++ /dev/null @@ -1,220 +0,0 @@ -const AVec = AbstractVector -const AMat = AbstractMatrix -const KW = Dict{Symbol, Any} -const AKW = AbstractDict{Symbol, Any} - -# -------------------------------- -# DefaultsDict -# -------------------------------- - -struct DefaultsDict <: AbstractDict{Symbol, Any} - explicit::KW - defaults::KW -end - -function Base.getindex(dd::DefaultsDict, k) - return haskey(dd.explicit, k) ? dd.explicit[k] : dd.defaults[k] -end -Base.haskey(dd::DefaultsDict, k) = haskey(dd.explicit, k) || haskey(dd.defaults, k) -Base.get(dd::DefaultsDict, k, default) = haskey(dd, k) ? dd[k] : default -function Base.get!(dd::DefaultsDict, k, default) - v = if haskey(dd, k) - dd[k] - else - dd.defaults[k] = default - end - return v -end -function Base.delete!(dd::DefaultsDict, k) - haskey(dd.explicit, k) && delete!(dd.explicit, k) - haskey(dd.defaults, k) && delete!(dd.defaults, k) -end -Base.length(dd::DefaultsDict) = length(union(keys(dd.explicit), keys(dd.defaults))) -function Base.iterate(dd::DefaultsDict) - exp_keys = keys(dd.explicit) - def_keys = setdiff(keys(dd.defaults), exp_keys) - key_list = collect(Iterators.flatten((exp_keys, def_keys))) - iterate(dd, (key_list, 1)) -end -function Base.iterate(dd::DefaultsDict, (key_list, i)) - i > length(key_list) && return nothing - k = key_list[i] - (k => dd[k], (key_list, i + 1)) -end - -Base.copy(dd::DefaultsDict) = DefaultsDict(copy(dd.explicit), dd.defaults) - -RecipesBase.is_explicit(dd::DefaultsDict, k) = haskey(dd.explicit, k) -isdefault(dd::DefaultsDict, k) = !is_explicit(dd, k) && haskey(dd.defaults, k) - -Base.setindex!(dd::DefaultsDict, v, k) = dd.explicit[k] = v - -# Reset to default value and return dict -reset_kw!(dd::DefaultsDict, k) = is_explicit(dd, k) ? delete!(dd.explicit, k) : dd -# Reset to default value and return old value -pop_kw!(dd::DefaultsDict, k) = is_explicit(dd, k) ? pop!(dd.explicit, k) : dd.defaults[k] -pop_kw!(dd::DefaultsDict, k, default) = - is_explicit(dd, k) ? pop!(dd.explicit, k) : get(dd.defaults, k, default) -# Fallbacks for dicts without defaults -reset_kw!(d::AKW, k) = delete!(d, k) -pop_kw!(d::AKW, k) = pop!(d, k) -pop_kw!(d::AKW, k, default) = pop!(d, k, default) - - -# -------------------------------- -# 3D types -# -------------------------------- - -abstract type AbstractSurface end - -"represents a contour or surface mesh" -struct Surface{M <: AMat} <: AbstractSurface - surf::M -end - -Surface(f::Function, x, y) = Surface(Float64[f(xi, yi) for yi in y, xi in x]) - -Base.Array(surf::Surface) = surf.surf - -for f in (:length, :size, :axes) - @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...) -end -Base.copy(surf::Surface) = Surface(copy(surf.surf)) -Base.eltype(surf::Surface{T}) where {T} = eltype(T) - - -struct Volume{T} - v::Array{T, 3} - x_extents::Tuple{T, T} - y_extents::Tuple{T, T} - z_extents::Tuple{T, T} -end - -default_extents(::Type{T}) where {T} = (zero(T), one(T)) - -function Volume( - v::Array{T, 3}, - x_extents = default_extents(T), - y_extents = default_extents(T), - z_extents = default_extents(T), -) where {T} - Volume(v, x_extents, y_extents, z_extents) -end - -Base.Array(vol::Volume) = vol.v -for f in (:length, :size) - @eval Base.$f(vol::Volume, args...) = $f(vol.v, args...) -end -Base.copy(vol::Volume{T}) where {T} = - Volume{T}(copy(vol.v), vol.x_extents, vol.y_extents, vol.z_extents) -Base.eltype(vol::Volume{T}) where {T} = T - - -# -------------------------------- -# Formatting -# -------------------------------- - -"Represents data values with formatting that should apply to the tick labels." -struct Formatted{T} - data::T - formatter::Function -end - -# ------------------------------- -# 3D seriestypes -# ------------------------------- - -# TODO: Move to RecipesBase? -""" - is3d(::Type{Val{:myseriestype}}) - -Returns `true` if `myseriestype` represents a 3D series, `false` otherwise. -""" -is3d(st) = false -for st in ( - :contour, - :contourf, - :contour3d, - :heatmap, - :image, - :path3d, - :scatter3d, - :surface, - :volume, - :wireframe, -) - @eval is3d(::Type{Val{Symbol($(string(st)))}}) = true -end -is3d(st::Symbol) = is3d(Val{st}) -is3d(plt, stv::AbstractArray) = all(st -> is3d(plt, st), stv) -is3d(plotattributes::AbstractDict) = is3d(get(plotattributes, :seriestype, :path)) - - -""" - is_surface(::Type{Val{:myseriestype}}) - -Returns `true` if `myseriestype` represents a surface series, `false` otherwise. -""" -is_surface(st) = false -for st in (:contour, :contourf, :contour3d, :image, :heatmap, :surface, :wireframe) - @eval is_surface(::Type{Val{Symbol($(string(st)))}}) = true -end -is_surface(st::Symbol) = is_surface(Val{st}) -is_surface(plt, stv::AbstractArray) = all(st -> is_surface(plt, st), stv) -is_surface(plotattributes::AbstractDict) = - is_surface(get(plotattributes, :seriestype, :path)) - - -""" - needs_3d_axes(::Type{Val{:myseriestype}}) - -Returns `true` if `myseriestype` needs 3d axes, `false` otherwise. -""" -needs_3d_axes(st) = false -for st in ( - :contour3d, - :path3d, - :scatter3d, - :surface, - :volume, - :wireframe, -) - @eval needs_3d_axes(::Type{Val{Symbol($(string(st)))}}) = true -end -needs_3d_axes(st::Symbol) = needs_3d_axes(Val{st}) -needs_3d_axes(plt, stv::AbstractArray) = all(st -> needs_3d_axes(plt, st), stv) -needs_3d_axes(plotattributes::AbstractDict) = - needs_3d_axes(get(plotattributes, :seriestype, :path)) - - -# -------------------------------- -# Scales -# -------------------------------- - -const SCALE_FUNCTIONS = Dict{Symbol, Function}(:log10 => log10, :log2 => log2, :ln => log) -const INVERSE_SCALE_FUNCTIONS = - Dict{Symbol, Function}(:log10 => exp10, :log2 => exp2, :ln => exp) - -scale_func(scale::Symbol) = x -> get(SCALE_FUNCTIONS, scale, identity)(Float64(x)) -inverse_scale_func(scale::Symbol) = - x -> get(INVERSE_SCALE_FUNCTIONS, scale, identity)(Float64(x)) - - -# -------------------------------- -# Unzip -# -------------------------------- - -for i in 2:4 - @eval begin - unzip(v::AVec{<:Tuple{Vararg{T, $i} where T}}) = - $(Expr(:tuple, (:([t[$j] for t in v]) for j in 1:i)...)) - end -end - - -# -------------------------------- -# Map functions on vectors -# -------------------------------- - -_map_funcs(f::Function, u::AVec) = map(f, u) -_map_funcs(fs::AVec{F}, u::AVec) where {F <: Function} = [map(f, u) for f in fs] diff --git a/src/pipeline.jl b/src/pipeline.jl index d64958b4..445075b4 100644 --- a/src/pipeline.jl +++ b/src/pipeline.jl @@ -142,7 +142,7 @@ function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW) end -RecipePipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], :x) +RecipePipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], letter) ## Plot recipes From b6139e24032f504d142786d89a639edd185f0a30 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Sun, 5 Apr 2020 12:01:25 +0200 Subject: [PATCH 06/17] remove include --- src/Plots.jl | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/Plots.jl b/src/Plots.jl index 70082e30..cba3c958 100644 --- a/src/Plots.jl +++ b/src/Plots.jl @@ -167,9 +167,8 @@ using .PlotMeasures import .PlotMeasures: Length, AbsoluteLength, Measure, width, height # --------------------------------------------------------- -include("RecipePipeline/RecipePipeline.jl") -import .RecipePipeline -import .RecipePipeline: SliceIt, +import RecipePipeline +import RecipePipeline: SliceIt, DefaultsDict, Formatted, AbstractSurface, From 28ce7d7995b70400cb48c047bf454eb149bb90b9 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Sun, 5 Apr 2020 12:02:19 +0200 Subject: [PATCH 07/17] add recipepipeline manually in travis --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index ccd58dfb..48361ed3 100644 --- a/.travis.yml +++ b/.travis.yml @@ -41,4 +41,4 @@ after_success: script: - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi - if [[ `uname` = "Linux" ]]; then TESTCMD="xvfb-run julia"; else TESTCMD="julia"; fi - - $TESTCMD -e 'using Pkg; Pkg.build(); Pkg.test(coverage=true)' + - $TESTCMD -e 'using Pkg; pkg"add https://github.com/JuliaPlots/RecipeUtils.jl"; Pkg.build(); Pkg.test(coverage=true)' From d8f516a456ebdbc2620316913a86b657070238da Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Sun, 5 Apr 2020 12:14:26 +0200 Subject: [PATCH 08/17] fix recipepipeline url in travis --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 48361ed3..89eb973c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -41,4 +41,4 @@ after_success: script: - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi - if [[ `uname` = "Linux" ]]; then TESTCMD="xvfb-run julia"; else TESTCMD="julia"; fi - - $TESTCMD -e 'using Pkg; pkg"add https://github.com/JuliaPlots/RecipeUtils.jl"; Pkg.build(); Pkg.test(coverage=true)' + - $TESTCMD -e 'using Pkg; pkg"add https://github.com/JuliaPlots/RecipePipeline.jl"; Pkg.build(); Pkg.test(coverage=true)' From 2a88ab77261f18434eb57c9e2929610aa95a8911 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Miclu=C8=9Ba-C=C3=A2mpeanu?= Date: Sun, 5 Apr 2020 16:21:05 +0300 Subject: [PATCH 09/17] Rename to RecipesPipeline --- .travis.yml | 2 +- Project.toml | 2 +- src/Plots.jl | 4 +- src/pipeline.jl | 44 +- src/plot.jl | 2 +- src/precompile.jl | 1058 ++++++++++++++++++++++----------------------- 6 files changed, 556 insertions(+), 556 deletions(-) diff --git a/.travis.yml b/.travis.yml index 89eb973c..c4234a2b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -41,4 +41,4 @@ after_success: script: - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi - if [[ `uname` = "Linux" ]]; then TESTCMD="xvfb-run julia"; else TESTCMD="julia"; fi - - $TESTCMD -e 'using Pkg; pkg"add https://github.com/JuliaPlots/RecipePipeline.jl"; Pkg.build(); Pkg.test(coverage=true)' + - $TESTCMD -e 'using Pkg; pkg"add https://github.com/JuliaPlots/RecipesPipeline.jl"; Pkg.build(); Pkg.test(coverage=true)' diff --git a/Project.toml b/Project.toml index f6ab3ef4..d7f2df00 100644 --- a/Project.toml +++ b/Project.toml @@ -21,7 +21,7 @@ PlotUtils = "995b91a9-d308-5afd-9ec6-746e21dbc043" Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7" REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" -RecipePipeline = "01d81517-befc-4cb6-b9ec-a95719d0359c" +RecipesPipeline = "01d81517-befc-4cb6-b9ec-a95719d0359c" RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" Reexport = "189a3867-3050-52da-a836-e630ba90ab69" Requires = "ae029012-a4dd-5104-9daa-d747884805df" diff --git a/src/Plots.jl b/src/Plots.jl index cba3c958..e8113cac 100644 --- a/src/Plots.jl +++ b/src/Plots.jl @@ -167,8 +167,8 @@ using .PlotMeasures import .PlotMeasures: Length, AbsoluteLength, Measure, width, height # --------------------------------------------------------- -import RecipePipeline -import RecipePipeline: SliceIt, +import RecipesPipeline +import RecipesPipeline: SliceIt, DefaultsDict, Formatted, AbstractSurface, diff --git a/src/pipeline.jl b/src/pipeline.jl index 445075b4..2392877f 100644 --- a/src/pipeline.jl +++ b/src/pipeline.jl @@ -1,8 +1,8 @@ -# RecipePipeline API +# RecipesPipeline API ## Warnings -function RecipePipeline.warn_on_recipe_aliases!( +function RecipesPipeline.warn_on_recipe_aliases!( plt::Plot, plotattributes, recipe_type, @@ -18,21 +18,21 @@ function RecipePipeline.warn_on_recipe_aliases!( end end end -function RecipePipeline.warn_on_recipe_aliases!( +function RecipesPipeline.warn_on_recipe_aliases!( plt::Plot, v::AbstractVector, recipe_type, args..., ) - foreach(x -> RecipePipeline.warn_on_recipe_aliases!(plt, x, recipe_type, args...), v) + foreach(x -> RecipesPipeline.warn_on_recipe_aliases!(plt, x, recipe_type, args...), v) end -function RecipePipeline.warn_on_recipe_aliases!( +function RecipesPipeline.warn_on_recipe_aliases!( plt::Plot, rd::RecipeData, recipe_type, args..., ) - RecipePipeline.warn_on_recipe_aliases!(plt, rd.plotattributes, recipe_type, args...) + RecipesPipeline.warn_on_recipe_aliases!(plt, rd.plotattributes, recipe_type, args...) end function _signature_string(::Type{Val{:user}}, args...) @@ -45,28 +45,28 @@ _signature_string(::Type{Val{:series}}, st) = "(::Type{Val{:$st}}, x, y, z)" ## Grouping -RecipePipeline.splittable_attribute(plt::Plot, key, val::SeriesAnnotations, len) = - RecipePipeline.splittable_attribute(plt, key, val.strs, len) +RecipesPipeline.splittable_attribute(plt::Plot, key, val::SeriesAnnotations, len) = + RecipesPipeline.splittable_attribute(plt, key, val.strs, len) -function RecipePipeline.split_attribute(plt::Plot, key, val::SeriesAnnotations, indices) - split_strs = _RecipePipeline.split_attribute(key, val.strs, indices) +function RecipesPipeline.split_attribute(plt::Plot, key, val::SeriesAnnotations, indices) + split_strs = _RecipesPipeline.split_attribute(key, val.strs, indices) return SeriesAnnotations(split_strs, val.font, val.baseshape, val.scalefactor) end ## Preprocessing attributes -RecipePipeline.preprocess_attributes!(plt::Plot, plotattributes) = +RecipesPipeline.preprocess_attributes!(plt::Plot, plotattributes) = preprocess_attributes!(plotattributes) # in src/args.jl -RecipePipeline.is_axis_attribute(plt::Plot, attr) = is_axis_attr_noletter(attr) # in src/args.jl +RecipesPipeline.is_axis_attribute(plt::Plot, attr) = is_axis_attr_noletter(attr) # in src/args.jl -RecipePipeline.is_subplot_attribute(plt::Plot, attr) = is_subplot_attr(attr) # in src/args.jl +RecipesPipeline.is_subplot_attribute(plt::Plot, attr) = is_subplot_attr(attr) # in src/args.jl ## User recipes -function RecipePipeline.process_userrecipe!(plt::Plot, kw_list, kw) +function RecipesPipeline.process_userrecipe!(plt::Plot, kw_list, kw) _preprocess_userrecipe(kw) warn_on_unsupported_scales(plt.backend, kw) # add the plot index @@ -142,22 +142,22 @@ function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW) end -RecipePipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], letter) +RecipesPipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], letter) ## Plot recipes -RecipePipeline.type_alias(plt::Plot) = get(_typeAliases, st, st) +RecipesPipeline.type_alias(plt::Plot) = get(_typeAliases, st, st) ## Plot setup -function RecipePipeline.plot_setup!(plt::Plot, plotattributes, kw_list) +function RecipesPipeline.plot_setup!(plt::Plot, plotattributes, kw_list) _plot_setup(plt, plotattributes, kw_list) _subplot_setup(plt, plotattributes, kw_list) end -# TODO: Should some of this logic be moved to RecipePipeline? +# TODO: Should some of this logic be moved to RecipesPipeline? function _plot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW}) # merge in anything meant for the Plot for kw in kw_list, (k, v) in kw @@ -269,18 +269,18 @@ end ## Series recipes -function RecipePipeline.slice_series_attributes!(plt::Plot, kw_list, kw) +function RecipesPipeline.slice_series_attributes!(plt::Plot, kw_list, kw) sp::Subplot = kw[:subplot] # in series attributes given as vector with one element per series, # select the value for current series _slice_series_args!(kw, plt, sp, series_idx(kw_list, kw)) end -RecipePipeline.series_defaults(plt::Plot) = _series_defaults # in args.jl +RecipesPipeline.series_defaults(plt::Plot) = _series_defaults # in args.jl -RecipePipeline.is_seriestype_supported(plt::Plot, st) = is_seriestype_supported(st) +RecipesPipeline.is_seriestype_supported(plt::Plot, st) = is_seriestype_supported(st) -function RecipePipeline.add_series!(plt::Plot, plotattributes) +function RecipesPipeline.add_series!(plt::Plot, plotattributes) sp = _prepare_subplot(plt, plotattributes) _expand_subplot_extrema(sp, plotattributes, plotattributes[:seriestype]) _update_series_attributes!(plotattributes, plt, sp) diff --git a/src/plot.jl b/src/plot.jl index eb91d772..3bd7e3ec 100644 --- a/src/plot.jl +++ b/src/plot.jl @@ -164,7 +164,7 @@ end # a list of series KW dicts. # note: at entry, we only have those preprocessed args which were passed in... no default values yet function _plot!(plt::Plot, plotattributes, args) - RecipePipeline.recipe_pipeline!(plt, plotattributes, args) + RecipesPipeline.recipe_pipeline!(plt, plotattributes, args) current(plt) _do_plot_show(plt, plt[:show]) return plt diff --git a/src/precompile.jl b/src/precompile.jl index 04bf94b5..0b24d3bb 100644 --- a/src/precompile.jl +++ b/src/precompile.jl @@ -47,493 +47,493 @@ function _precompile_() isdefined(Plots, Symbol("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:marker_z, :color, :legend), Tuple{typeof(Base.:+), Symbol, Bool}}, typeof(Plots.scatter), Array{Float64, 1}, Array{Float64, 1}}) isdefined(Plots, Symbol("#standalone_html##kw")) && precompile(Tuple{getfield(Plots, Symbol("#standalone_html##kw")), NamedTuple{(:title,), Tuple{String}}, typeof(Plots.standalone_html), Plots.Plot{Plots.PlotlyBackend}}) isdefined(Plots, Symbol("#test_examples##kw")) && precompile(Tuple{getfield(Plots, Symbol("#test_examples##kw")), NamedTuple{(:skip,), Tuple{Array{Int64, 1}}}, typeof(Plots.test_examples), Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{Float64, 1}, 1}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{T, 1} where T, 1}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Dates.DateTime, 1}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Function, 1}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Int64, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity), Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, Base.UnitRange{Int64}, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, typeof(identity), Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{String, 1}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{String, 1}, Array{String, 1}, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRange{Int64, Int64}, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Array{Union{Base.Missing, Float64}, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Base.UnitRange{Int64}, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Nothing, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Nothing}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipePipeline._extract_group_attributes), Array{String, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._filter_input_data!), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._finish_userrecipe!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData}) - precompile(Tuple{typeof(Plots.RecipePipeline._finish_userrecipe!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData}) - precompile(Tuple{typeof(Plots.RecipePipeline._nobigs), Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._postprocess_axis_args!), Base.Dict{Symbol, Any}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Real, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Union{Base.Missing, Number}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._preprocess_axis_args!), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_fillrange), Int64, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_fillrange), Nothing, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipe), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipe), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Int64, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Nothing, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Tuple{Base.LinRange{Float64}, Base.LinRange{Float64}}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), typeof(identity), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipe), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipe), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipePipeline._scaled_adapted_grid), typeof(identity), Symbol, Symbol, Float64, Float64}) - precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Array{Float64, 1}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Array{T, 1} where T, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Float64, 2}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Function, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Real, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Union{Base.Missing, Int64}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Union{Base.Missing, Number}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), typeof(identity), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline.add_series!), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipePipeline.add_series!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipePipeline.filter_data!), Base.Dict{Symbol, Any}, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.filter_data), Array{Float64, 1}, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.filter_data), Base.OneTo{Int64}, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.filter_data), Nothing, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Array{Symbol, 2}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Plots.Subplot{Plots.GRBackend}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Plots.Subplot{Plots.PlotlyBackend}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Base.Val{:contour}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Base.Val{:heatmap}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Base.Val{:path3d}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Int}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is_axis_attribute), Plots.Plot{Plots.GRBackend}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.is_axis_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.is_seriestype_supported), Plots.Plot{Plots.GRBackend}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.is_seriestype_supported), Plots.Plot{Plots.PlotlyBackend}, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Type{Base.Val{:contour}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Type{Base.Val{:heatmap}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Type{Int}}) - precompile(Tuple{typeof(Plots.RecipePipeline.needs_3d_axes), Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.needs_3d_axes), Type{Base.Val{:path3d}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.needs_3d_axes), Type{Int}}) - precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipePipeline.process_userrecipe!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline.process_userrecipe!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipePipeline.slice_series_attributes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline.slice_series_attributes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{Int64, 1}, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{String, 1}, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{Symbol, 2}, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Plots.GridLayout, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Plots.Plot{Plots.GRBackend}, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, String, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Symbol, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{Int64, 1}, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{String, 1}, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{Symbol, 2}, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Plots.GridLayout, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Plots.Plot{Plots.PlotlyBackend}, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, String, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Symbol, Int64}) - precompile(Tuple{typeof(Plots.RecipePipeline.unzip), Array{Tuple{Array{Float64, 1}, Array{Float64, 1}}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.unzip), Array{Tuple{Float64, Float64, Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Int64, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Int64, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipePipeline.wrap_surfaces!), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{Float64, 1}, 1}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{T, 1} where T, 1}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Dates.DateTime, 1}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Function, 1}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Int64, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity), Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{Float64, 1}, Base.UnitRange{Int64}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{Float64, 1}, typeof(identity), Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{String, 1}, Array{Float64, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{String, 1}, Array{String, 1}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Base.StepRange{Int64, Int64}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Nothing, Array{Float64, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Nothing, Array{Union{Base.Missing, Float64}, 1}, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Nothing, Base.UnitRange{Int64}, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Nothing, Nothing, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Nothing, Plots.RecipesPipeline.Surface{Array{Float64, 2}}, Nothing}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Function, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Function, 1}, Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._extract_group_attributes), Array{String, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._filter_input_data!), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._finish_userrecipe!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData}) + precompile(Tuple{typeof(Plots.RecipesPipeline._finish_userrecipe!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData}) + precompile(Tuple{typeof(Plots.RecipesPipeline._nobigs), Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._postprocess_axis_args!), Base.Dict{Symbol, Any}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Real, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Union{Base.Missing, Number}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._preprocess_axis_args!), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_fillrange), Int64, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_fillrange), Nothing, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_plotrecipe), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_plotrecipe), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_plotrecipes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_plotrecipes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_ribbon), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_ribbon), Int64, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_ribbon), Nothing, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_ribbon), Tuple{Base.LinRange{Float64}, Base.LinRange{Float64}}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_ribbon), typeof(identity), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_seriesrecipe), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_seriesrecipe), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_seriesrecipes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_seriesrecipes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._scaled_adapted_grid), typeof(identity), Symbol, Symbol, Float64, Float64}) + precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Array{Float64, 1}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Array{T, 1} where T, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Float64, 2}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Function, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Real, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Union{Base.Missing, Int64}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Union{Base.Missing, Number}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), typeof(identity), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.add_series!), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipesPipeline.add_series!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipesPipeline.filter_data!), Base.Dict{Symbol, Any}, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.filter_data), Array{Float64, 1}, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.filter_data), Base.OneTo{Int64}, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.filter_data), Nothing, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Array{Symbol, 2}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Plots.Subplot{Plots.GRBackend}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Plots.Subplot{Plots.PlotlyBackend}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Type{Base.Val{:contour}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Type{Base.Val{:heatmap}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Type{Base.Val{:path3d}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Type{Int}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is_axis_attribute), Plots.Plot{Plots.GRBackend}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is_axis_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is_seriestype_supported), Plots.Plot{Plots.GRBackend}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is_seriestype_supported), Plots.Plot{Plots.PlotlyBackend}, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is_surface), Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is_surface), Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is_surface), Type{Base.Val{:contour}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is_surface), Type{Base.Val{:heatmap}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.is_surface), Type{Int}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.needs_3d_axes), Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.needs_3d_axes), Type{Base.Val{:path3d}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.needs_3d_axes), Type{Int}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.preprocess_attributes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.preprocess_attributes!), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipesPipeline.preprocess_attributes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.preprocess_attributes!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.RecipesPipeline.process_userrecipe!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.process_userrecipe!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.slice_series_attributes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.slice_series_attributes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{Int64, 1}, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{String, 1}, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{Symbol, 2}, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Plots.GridLayout, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Plots.Plot{Plots.GRBackend}, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, String, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Symbol, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{Int64, 1}, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{String, 1}, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{Symbol, 2}, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Plots.GridLayout, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Plots.Plot{Plots.PlotlyBackend}, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, String, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Symbol, Int64}) + precompile(Tuple{typeof(Plots.RecipesPipeline.unzip), Array{Tuple{Array{Float64, 1}, Array{Float64, 1}}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.unzip), Array{Tuple{Float64, Float64, Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Int64, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipesPipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipesPipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Int64, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipesPipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipesPipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipesPipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Base.Complex{Float64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Dates.DateTime, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 2}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Function, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{String, 1}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Tuple{Int64, Real}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Union{Base.Missing, Int64}, 1}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.StepRange{Int64, Int64}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.UnitRange{Int64}}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Nothing, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.PortfolioComposition}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipesPipeline.GroupBy, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.Spy}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Type{Int}, Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, typeof(identity), Int}) + precompile(Tuple{typeof(Plots.RecipesPipeline.wrap_surfaces!), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.__init__)}) precompile(Tuple{typeof(Plots._add_errorbar_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots._add_markershape), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots._add_smooth_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots._backend_instance), Symbol}) precompile(Tuple{typeof(Plots._bin_centers), Array{Float64, 1}}) precompile(Tuple{typeof(Plots._binbarlike_baseline), Float64, Symbol}) @@ -570,15 +570,15 @@ function _precompile_() precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Bool}) precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Symbol}) precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.PlotlyBackend}, Bool}) - precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Symbol}) - precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Symbol}) + precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol}) + precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol}) precompile(Tuple{typeof(Plots._heatmap_edges), Array{Float64, 1}, Bool}) precompile(Tuple{typeof(Plots._hist_edge), Tuple{Array{Float64, 1}}, Int64, Symbol}) precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64}) precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}}) precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}}, Symbol}) precompile(Tuple{typeof(Plots._initialize_backend), Plots.PlotlyBackend}) - precompile(Tuple{typeof(Plots._override_seriestype_check), Plots.RecipePipeline.DefaultsDict, Symbol}) + precompile(Tuple{typeof(Plots._override_seriestype_check), Plots.RecipesPipeline.DefaultsDict, Symbol}) precompile(Tuple{typeof(Plots._pick_default_backend)}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) @@ -636,24 +636,24 @@ function _precompile_() precompile(Tuple{typeof(Plots._plot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}}) precompile(Tuple{typeof(Plots._plotly_framestyle), Symbol}) precompile(Tuple{typeof(Plots._plots_defaults)}) - precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipePipeline.DefaultsDict, Array{Float64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipePipeline.DefaultsDict, Array{Int64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipePipeline.DefaultsDict, Base.OneTo{Int64}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots._preprocess_binlike), Plots.RecipePipeline.DefaultsDict, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipesPipeline.DefaultsDict, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipesPipeline.DefaultsDict, Array{Int64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipesPipeline.DefaultsDict, Base.OneTo{Int64}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._preprocess_binlike), Plots.RecipesPipeline.DefaultsDict, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}) precompile(Tuple{typeof(Plots._preprocess_userrecipe), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._replace_linewidth), Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._replace_linewidth), Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots._replace_markershape), Array{Symbol, 2}}) precompile(Tuple{typeof(Plots._replace_markershape), Plots.Shape}) precompile(Tuple{typeof(Plots._scale_adjusted_values), Type{Float64}, Array{Float64, 1}, Symbol}) - precompile(Tuple{typeof(Plots._series_index), Plots.RecipePipeline.DefaultsDict, Plots.Subplot{Plots.GRBackend}}) - precompile(Tuple{typeof(Plots._series_index), Plots.RecipePipeline.DefaultsDict, Plots.Subplot{Plots.PlotlyBackend}}) + precompile(Tuple{typeof(Plots._series_index), Plots.RecipesPipeline.DefaultsDict, Plots.Subplot{Plots.GRBackend}}) + precompile(Tuple{typeof(Plots._series_index), Plots.RecipesPipeline.DefaultsDict, Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._show), Base.IOStream, Base.Multimedia.MIME{Symbol("image/png")}, Plots.Plot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64}) precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64}) - precompile(Tuple{typeof(Plots._slice_series_args!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64}) - precompile(Tuple{typeof(Plots._slice_series_args!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64}) + precompile(Tuple{typeof(Plots._slice_series_args!), Plots.RecipesPipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64}) + precompile(Tuple{typeof(Plots._slice_series_args!), Plots.RecipesPipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64}) precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}}) precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}}) precompile(Tuple{typeof(Plots._transform_ticks), Base.StepRange{Int64, Int64}}) @@ -661,11 +661,11 @@ function _precompile_() precompile(Tuple{typeof(Plots._transform_ticks), Nothing}) precompile(Tuple{typeof(Plots._transform_ticks), Symbol}) precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Base.Dict{Symbol, Any}, Symbol, Int64}) - precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Plots.RecipePipeline.DefaultsDict, Symbol, Int64}) + precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Plots.RecipesPipeline.DefaultsDict, Symbol, Int64}) precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64}) - precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Int64}) + precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol, Int64}) precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Int64}) - precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Int64}) + precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol, Int64}) precompile(Tuple{typeof(Plots._update_axis_colors), Plots.Axis}) precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.GRBackend}, Plots.Axis, Symbol}) precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.PlotlyBackend}, Plots.Axis, Symbol}) @@ -675,22 +675,22 @@ function _precompile_() precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}}) - precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}}) + precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.RecipesPipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}}) + precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.RecipesPipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Int64, Bool}) - precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Int64, Bool}) + precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict, Int64, Bool}) precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Int64, Bool}) - precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Int64, Bool}) + precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict, Int64, Bool}) precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.GRBackend}, Array{Any, 1}}) precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.PlotlyBackend}, Array{Any, 1}}) precompile(Tuple{typeof(Plots.addExtension), String, String}) precompile(Tuple{typeof(Plots.add_layout_pct!), Base.Dict{Symbol, Any}, Expr, Int64, Int64}) - precompile(Tuple{typeof(Plots.aliasesAndAutopick), Plots.RecipePipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64}) + precompile(Tuple{typeof(Plots.aliasesAndAutopick), Plots.RecipesPipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64}) precompile(Tuple{typeof(Plots.allAlphas), Int64}) precompile(Tuple{typeof(Plots.allStyles), Int64}) precompile(Tuple{typeof(Plots.allStyles), Symbol}) @@ -724,10 +724,10 @@ function _precompile_() precompile(Tuple{typeof(Plots.bottompad), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64, Array{Plots.Plot{T} where T<:RecipesBase.AbstractBackend, 1}}) precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64}) - precompile(Tuple{typeof(Plots.build_layout), Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.build_layout), Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.EmptyLayout}) precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.GridLayout}) - precompile(Tuple{typeof(Plots.color_or_nothing!), Plots.RecipePipeline.DefaultsDict, Symbol}) + precompile(Tuple{typeof(Plots.color_or_nothing!), Plots.RecipesPipeline.DefaultsDict, Symbol}) precompile(Tuple{typeof(Plots.colorbar_style), Plots.Series}) precompile(Tuple{typeof(Plots.compute_gridsize), Int64, Int64, Int64}) precompile(Tuple{typeof(Plots.concatenate_fillrange), Base.UnitRange{Int64}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) @@ -753,7 +753,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Base.Missing}) precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Char}) precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, String}) - precompile(Tuple{typeof(Plots.ensure_gradient!), Plots.RecipePipeline.DefaultsDict, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.ensure_gradient!), Plots.RecipesPipeline.DefaultsDict, Symbol, Symbol}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Float64, 1}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Int64, 1}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.OneTo{Int64}}) @@ -762,14 +762,14 @@ function _precompile_() precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.UnitRange{Int64}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Float64}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Int64}) - precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Tuple{Float64, Float64}}) - precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.extend_by_data!), Array{Float64, 1}, Float64}) precompile(Tuple{typeof(Plots.extend_series_data!), Plots.Series, Float64, Symbol}) precompile(Tuple{typeof(Plots.fakedata), Int64, Int64}) - precompile(Tuple{typeof(Plots.fg_color), Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.fg_color), Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.font), Int64, Int}) precompile(Tuple{typeof(Plots.font), String, Int}) precompile(Tuple{typeof(Plots.font), Symbol, Int}) @@ -948,7 +948,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.isvertical), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.isvertical), Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.isvertical), Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}, Int}) precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}}) precompile(Tuple{typeof(Plots.iter_segments), Array{Int64, 1}, Array{Float64, 1}}) @@ -966,7 +966,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.layout_args), Int64, Tuple{Int64, Int64}}) precompile(Tuple{typeof(Plots.layout_args), Int64}) precompile(Tuple{typeof(Plots.layout_args), Plots.GridLayout}) - precompile(Tuple{typeof(Plots.layout_args), Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.layout_args), Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}}) precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}) precompile(Tuple{typeof(Plots.leftpad), Plots.Subplot{Plots.GRBackend}}) @@ -1022,7 +1022,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.StepRange{Int64, Int64}}) precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.UnitRange{Int64}}) precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Nothing}) - precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.plotly_domain), Plots.Subplot{Plots.PlotlyBackend}, Symbol}) precompile(Tuple{typeof(Plots.plotly_font), Plots.Font, ColorTypes.RGBA{Float64}}) precompile(Tuple{typeof(Plots.plotly_font), Plots.Font}) @@ -1041,7 +1041,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}) precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRange{Int64, Int64}}) precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.plotly_polar!), Base.Dict{Symbol, Any}, Plots.Series}) precompile(Tuple{typeof(Plots.plotly_polaraxis), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis}) precompile(Tuple{typeof(Plots.plotly_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Series}) @@ -1056,12 +1056,12 @@ function _precompile_() precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.UnitRange{Int64}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}}) precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Nothing, Nothing, Nothing, Tuple{Float64, Float64}}) precompile(Tuple{typeof(Plots.plotly_series_shapes), Plots.Plot{Plots.PlotlyBackend}, Plots.Series, Tuple{Float64, Float64}}) - precompile(Tuple{typeof(Plots.plotly_surface_data), Plots.Series, Plots.RecipePipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.plotly_surface_data), Plots.Series, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.png), Plots.Plot{Plots.GRBackend}, String}) precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.preprocess_attributes!), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.preprocess_attributes!), Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.preprocess_attributes!), Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Bool}) precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Int64}) precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol}) @@ -1072,7 +1072,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Float64, Symbol}) precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Int64, Symbol}) precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.processGridArg!), Plots.RecipePipeline.DefaultsDict, Bool, Symbol}) + precompile(Tuple{typeof(Plots.processGridArg!), Plots.RecipesPipeline.DefaultsDict, Bool, Symbol}) precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Array{Symbol, 2}}) precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Float64}) precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Int64}) @@ -1096,9 +1096,9 @@ function _precompile_() precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, Tuple{Int64, Int64}, Symbol}) precompile(Tuple{typeof(Plots.recompute_lengths), Array{Measures.Measure, 1}}) precompile(Tuple{typeof(Plots.replaceAlias!), Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Symbol}}) - precompile(Tuple{typeof(Plots.replaceAlias!), Plots.RecipePipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}}) + precompile(Tuple{typeof(Plots.replaceAlias!), Plots.RecipesPipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}}) precompile(Tuple{typeof(Plots.replaceAliases!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Symbol}}) - precompile(Tuple{typeof(Plots.replaceAliases!), Plots.RecipePipeline.DefaultsDict, Base.Dict{Symbol, Symbol}}) + precompile(Tuple{typeof(Plots.replaceAliases!), Plots.RecipesPipeline.DefaultsDict, Base.Dict{Symbol, Symbol}}) precompile(Tuple{typeof(Plots.reset_axis_defaults_byletter!)}) precompile(Tuple{typeof(Plots.right), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}}) precompile(Tuple{typeof(Plots.rightpad), Plots.Subplot{Plots.GRBackend}}) @@ -1114,8 +1114,8 @@ function _precompile_() precompile(Tuple{typeof(Plots.showaxis), Symbol, Symbol}) precompile(Tuple{typeof(Plots.shrink_by), Float64, Float64, Float64}) precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Int64, Bool}) - precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Plots.RecipePipeline.DefaultsDict, Symbol, Int64, Bool}) - precompile(Tuple{typeof(Plots.slice_arg!), Plots.RecipePipeline.DefaultsDict, Plots.RecipePipeline.DefaultsDict, Symbol, Int64, Bool}) + precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Plots.RecipesPipeline.DefaultsDict, Symbol, Int64, Bool}) + precompile(Tuple{typeof(Plots.slice_arg!), Plots.RecipesPipeline.DefaultsDict, Plots.RecipesPipeline.DefaultsDict, Symbol, Int64, Bool}) precompile(Tuple{typeof(Plots.slice_arg), Array{ColorTypes.RGBA{Float64}, 2}, Int64}) precompile(Tuple{typeof(Plots.slice_arg), Array{Measures.Length{:mm, Float64}, 2}, Int64}) precompile(Tuple{typeof(Plots.slice_arg), Array{String, 2}, Int64}) @@ -1167,10 +1167,10 @@ function _precompile_() precompile(Tuple{typeof(Plots.update_inset_bboxes!), Plots.Plot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.vline!), Array{Int64, 1}}) precompile(Tuple{typeof(Plots.wand_edges), Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.GRBackend, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.PlotlyBackend, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.GRBackend, Plots.RecipePipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.PlotlyBackend, Plots.RecipePipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.GRBackend, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.PlotlyBackend, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.GRBackend, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.PlotlyBackend, Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.warn_on_unsupported_scales), Plots.GRBackend, Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.warn_on_unsupported_scales), Plots.PlotlyBackend, Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.widen), Float64, Float64, Symbol}) From 92d8bd7836b4979d78bbbc65ac2bebd80a374309 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Sun, 5 Apr 2020 17:17:22 +0200 Subject: [PATCH 10/17] move some recipes to recipepipeline --- src/Plots.jl | 5 ++++- src/axes.jl | 4 ++-- src/recipes.jl | 20 -------------------- 3 files changed, 6 insertions(+), 23 deletions(-) diff --git a/src/Plots.jl b/src/Plots.jl index e8113cac..4eb76c34 100644 --- a/src/Plots.jl +++ b/src/Plots.jl @@ -182,7 +182,10 @@ import RecipesPipeline: SliceIt, pop_kw!, scale_func, inverse_scale_func, - unzip + unzip, + dateformatter, + datetimeformatter, + timeformatter include("types.jl") include("utils.jl") diff --git a/src/axes.jl b/src/axes.jl index 4069b4e6..76c465d1 100644 --- a/src/axes.jl +++ b/src/axes.jl @@ -139,7 +139,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing) # rather than on the input format # TODO: maybe: non-trivial scale (:ln, :log2, :log10) for date/datetime if ticks === nothing && scale == :identity - if axis[:formatter] == dateformatter + if axis[:formatter] == RecipesPipeline.dateformatter # optimize_datetime_ticks returns ticks and labels(!) based on # integers/floats corresponding to the DateTime type. Thus, the axes # limits, which resulted from converting the Date type to integers, @@ -150,7 +150,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing) k_min = 2, k_max = 4) # Now the ticks are converted back to floats corresponding to Dates. return ticks / 864e5, labels - elseif axis[:formatter] == datetimeformatter + elseif axis[:formatter] == RecipesPipeline.datetimeformatter return optimize_datetime_ticks(amin, amax; k_min = 2, k_max = 4) end end diff --git a/src/recipes.jl b/src/recipes.jl index 5b8d6694..6fcea5ad 100644 --- a/src/recipes.jl +++ b/src/recipes.jl @@ -1415,26 +1415,6 @@ abline!(plt::Plot, a, b; kw...) = abline!(args...; kw...) = abline!(current(), args...; kw...) - -# ------------------------------------------------- -# Dates & Times - -dateformatter(dt) = string(Date(Dates.UTD(dt))) -datetimeformatter(dt) = string(DateTime(Dates.UTM(dt))) -timeformatter(t) = string(Dates.Time(Dates.Nanosecond(t))) - -@recipe f(::Type{Date}, dt::Date) = (dt -> Dates.value(dt), dateformatter) -@recipe f(::Type{DateTime}, dt::DateTime) = - (dt -> Dates.value(dt), datetimeformatter) -@recipe f(::Type{Dates.Time}, t::Dates.Time) = (t -> Dates.value(t), timeformatter) -@recipe f(::Type{P}, t::P) where {P<:Dates.Period} = - (t -> Dates.value(t), t -> string(P(t))) - -# ------------------------------------------------- -# Characters - -@recipe f(::Type{<:AbstractChar}, ::AbstractChar) = (string, string) - # ------------------------------------------------- # Complex Numbers From 9fe3428a5502797dc9e8f83d4dfd60ef53df4076 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Fri, 10 Apr 2020 13:39:21 +0200 Subject: [PATCH 11/17] update Project.toml --- Project.toml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Project.toml b/Project.toml index d7f2df00..eae4e689 100644 --- a/Project.toml +++ b/Project.toml @@ -21,8 +21,8 @@ PlotUtils = "995b91a9-d308-5afd-9ec6-746e21dbc043" Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7" REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" -RecipesPipeline = "01d81517-befc-4cb6-b9ec-a95719d0359c" RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +RecipesPipeline = "01d81517-befc-4cb6-b9ec-a95719d0359c" Reexport = "189a3867-3050-52da-a836-e630ba90ab69" Requires = "ae029012-a4dd-5104-9daa-d747884805df" Showoff = "992d4aef-0814-514b-bc4d-f2e9a6c4116f" @@ -44,6 +44,7 @@ PGFPlotsX = "1.2.0" PlotThemes = "1" PlotUtils = "0.6.5" RecipesBase = "1" +RecipesPipeline = "0.1.1" Reexport = "0.2" Requires = "0.5, 1" Showoff = "0.3.1" From 059985c91ca213c9474a3a67ffee33e5a7eab44c Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Fri, 10 Apr 2020 13:47:03 +0200 Subject: [PATCH 12/17] revert travis test command --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index c4234a2b..ccd58dfb 100644 --- a/.travis.yml +++ b/.travis.yml @@ -41,4 +41,4 @@ after_success: script: - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi - if [[ `uname` = "Linux" ]]; then TESTCMD="xvfb-run julia"; else TESTCMD="julia"; fi - - $TESTCMD -e 'using Pkg; pkg"add https://github.com/JuliaPlots/RecipesPipeline.jl"; Pkg.build(); Pkg.test(coverage=true)' + - $TESTCMD -e 'using Pkg; Pkg.build(); Pkg.test(coverage=true)' From 7d697953646a97e386e87c63e70b5e39cb2b803d Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Fri, 10 Apr 2020 16:14:59 +0200 Subject: [PATCH 13/17] require julia version 1.1 --- .travis.yml | 2 +- Project.toml | 4 ++-- appveyor.yml | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index ccd58dfb..9fac2036 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,7 +4,7 @@ os: - linux # - osx julia: - - 1.0 + - 1.1 - 1 - nightly diff --git a/Project.toml b/Project.toml index eae4e689..967c74db 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,7 @@ name = "Plots" uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" author = ["Tom Breloff (@tbreloff)"] -version = "1.0.7" +version = "1.1.0" [deps] Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" @@ -49,7 +49,7 @@ Reexport = "0.2" Requires = "0.5, 1" Showoff = "0.3.1" StatsBase = "0.32, 0.33" -julia = "1" +julia = "1.1" [extras] FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" diff --git a/appveyor.yml b/appveyor.yml index 081e56df..ca9c454d 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,6 +1,6 @@ environment: matrix: - - julia_version: 1.0 + - julia_version: 1.1 - julia_version: 1 - julia_version: nightly From 4c43f0ea2f6010d434cba371232439b4f800e91a Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Fri, 10 Apr 2020 19:06:53 +0200 Subject: [PATCH 14/17] be explicit about RecipesPipeline imports --- src/Plots.jl | 2 +- src/args.jl | 38 ++++++++++++++++++------------------ src/axes.jl | 34 ++++++++++++++++---------------- src/backends.jl | 2 +- src/backends/gr.jl | 20 +++++++++---------- src/backends/pgfplots.jl | 8 ++++---- src/backends/pgfplotsx.jl | 10 +++++----- src/backends/plotly.jl | 10 +++++----- src/backends/pyplot.jl | 8 ++++---- src/backends/unicodeplots.jl | 2 +- src/components.jl | 2 +- src/pipeline.jl | 8 ++++---- src/plot.jl | 8 +++----- src/recipes.jl | 8 ++++---- src/utils.jl | 16 +++++++-------- 15 files changed, 87 insertions(+), 89 deletions(-) diff --git a/src/Plots.jl b/src/Plots.jl index 4eb76c34..7ec451f1 100644 --- a/src/Plots.jl +++ b/src/Plots.jl @@ -177,7 +177,7 @@ import RecipesPipeline: SliceIt, is3d, is_surface, needs_3d_axes, - group_as_matrix, + group_as_matrix, # for StatsPlots reset_kw!, pop_kw!, scale_func, diff --git a/src/args.jl b/src/args.jl index e303ed32..a6134e74 100644 --- a/src/args.jl +++ b/src/args.jl @@ -86,10 +86,10 @@ const _surface_like = [:contour, :contourf, :contour3d, :heatmap, :surface, :wir like_histogram(seriestype::Symbol) = seriestype in _histogram_like like_line(seriestype::Symbol) = seriestype in _line_like -like_surface(seriestype::Symbol) = is_surface(seriestype) +like_surface(seriestype::Symbol) = RecipesPipeline.is_surface(seriestype) -is3d(series::Series) = is3d(series.plotattributes) -is3d(sp::Subplot) = string(sp.attr[:projection]) == "3d" +RecipesPipeline.is3d(series::Series) = RecipesPipeline.is3d(series.plotattributes) +RecipesPipeline.is3d(sp::Subplot) = string(sp.attr[:projection]) == "3d" ispolar(sp::Subplot) = string(sp.attr[:projection]) == "polar" ispolar(series::Series) = ispolar(series.plotattributes[:subplot]) @@ -682,7 +682,7 @@ end function default(; kw...) kw = KW(kw) - preprocess_attributes!(kw) + RecipesPipeline.preprocess_attributes!(kw) for (k,v) in kw default(k, v) end @@ -935,11 +935,11 @@ function _add_markershape(plotattributes::AKW) end "Handle all preprocessing of args... break out colors/sizes/etc and replace aliases." -function preprocess_attributes!(plotattributes::AKW) +function RecipesPipeline.preprocess_attributes!(plotattributes::AKW) replaceAliases!(plotattributes, _keyAliases) # handle axis args common to all axis - args = pop_kw!(plotattributes, :axis, ()) + args = RecipesPipeline.pop_kw!(plotattributes, :axis, ()) for arg in wraptuple(args) for letter in (:x, :y, :z) process_axis_arg!(plotattributes, arg, letter) @@ -948,7 +948,7 @@ function preprocess_attributes!(plotattributes::AKW) # handle axis args for letter in (:x, :y, :z) asym = Symbol(letter, :axis) - args = pop_kw!(plotattributes, asym, ()) + args = RecipesPipeline.pop_kw!(plotattributes, asym, ()) if !(typeof(args) <: Axis) for arg in wraptuple(args) process_axis_arg!(plotattributes, arg, letter) @@ -966,7 +966,7 @@ function preprocess_attributes!(plotattributes::AKW) end # handle grid args common to all axes - args = pop_kw!(plotattributes, :grid, ()) + args = RecipesPipeline.pop_kw!(plotattributes, :grid, ()) for arg in wraptuple(args) for letter in (:x, :y, :z) processGridArg!(plotattributes, arg, letter) @@ -975,13 +975,13 @@ function preprocess_attributes!(plotattributes::AKW) # handle individual axes grid args for letter in (:x, :y, :z) gridsym = Symbol(letter, :grid) - args = pop_kw!(plotattributes, gridsym, ()) + args = RecipesPipeline.pop_kw!(plotattributes, gridsym, ()) for arg in wraptuple(args) processGridArg!(plotattributes, arg, letter) end end # handle minor grid args common to all axes - args = pop_kw!(plotattributes, :minorgrid, ()) + args = RecipesPipeline.pop_kw!(plotattributes, :minorgrid, ()) for arg in wraptuple(args) for letter in (:x, :y, :z) processMinorGridArg!(plotattributes, arg, letter) @@ -990,14 +990,14 @@ function preprocess_attributes!(plotattributes::AKW) # handle individual axes grid args for letter in (:x, :y, :z) gridsym = Symbol(letter, :minorgrid) - args = pop_kw!(plotattributes, gridsym, ()) + args = RecipesPipeline.pop_kw!(plotattributes, gridsym, ()) for arg in wraptuple(args) processMinorGridArg!(plotattributes, arg, letter) end end # handle font args common to all axes for fontname in (:tickfont, :guidefont) - args = pop_kw!(plotattributes, fontname, ()) + args = RecipesPipeline.pop_kw!(plotattributes, fontname, ()) for arg in wraptuple(args) for letter in (:x, :y, :z) processFontArg!(plotattributes, Symbol(letter, fontname), arg) @@ -1007,7 +1007,7 @@ function preprocess_attributes!(plotattributes::AKW) # handle individual axes font args for letter in (:x, :y, :z) for fontname in (:tickfont, :guidefont) - args = pop_kw!(plotattributes, Symbol(letter, fontname), ()) + args = RecipesPipeline.pop_kw!(plotattributes, Symbol(letter, fontname), ()) for arg in wraptuple(args) processFontArg!(plotattributes, Symbol(letter, fontname), arg) end @@ -1028,14 +1028,14 @@ function preprocess_attributes!(plotattributes::AKW) # fonts for fontname in (:titlefont, :legendfont, :legendtitlefont) - args = pop_kw!(plotattributes, fontname, ()) + args = RecipesPipeline.pop_kw!(plotattributes, fontname, ()) for arg in wraptuple(args) processFontArg!(plotattributes, fontname, arg) end end # handle line args - for arg in wraptuple(pop_kw!(plotattributes, :line, ())) + for arg in wraptuple(RecipesPipeline.pop_kw!(plotattributes, :line, ())) processLineArg(plotattributes, arg) end @@ -1049,7 +1049,7 @@ function preprocess_attributes!(plotattributes::AKW) processMarkerArg(plotattributes, arg) anymarker = true end - reset_kw!(plotattributes, :marker) + RecipesPipeline.reset_kw!(plotattributes, :marker) if haskey(plotattributes, :markershape) plotattributes[:markershape] = _replace_markershape(plotattributes[:markershape]) if plotattributes[:markershape] == :none && plotattributes[:seriestype] in (:scatter, :scatterbins, :scatterhist, :scatter3d) #the default should be :auto, not :none, so that :none can be set explicitly and would be respected @@ -1063,7 +1063,7 @@ function preprocess_attributes!(plotattributes::AKW) for arg in wraptuple(get(plotattributes, :fill, ())) processFillArg(plotattributes, arg) end - reset_kw!(plotattributes, :fill) + RecipesPipeline.reset_kw!(plotattributes, :fill) # handle series annotations if haskey(plotattributes, :series_annotations) @@ -1212,7 +1212,7 @@ function slice_arg!(plotattributes_in, plotattributes_out, v end if remove_pair - reset_kw!(plotattributes_in, k) + RecipesPipeline.reset_kw!(plotattributes_in, k) end return end @@ -1473,7 +1473,7 @@ end # update a subplots args and axes function _update_subplot_args(plt::Plot, sp::Subplot, plotattributes_in, subplot_index::Int, remove_pair::Bool) - anns = pop_kw!(sp.attr, :annotations) + anns = RecipesPipeline.pop_kw!(sp.attr, :annotations) # # grab those args which apply to this subplot for k in keys(_subplot_defaults) diff --git a/src/axes.jl b/src/axes.jl index 76c465d1..1820727c 100644 --- a/src/axes.jl +++ b/src/axes.jl @@ -85,7 +85,7 @@ function attr!(axis::Axis, args...; kw...) end # then preprocess keyword arguments - preprocess_attributes!(KW(kw)) + RecipesPipeline.preprocess_attributes!(KW(kw)) # then override for any keywords... only those keywords that already exists in plotattributes for (k,v) in kw @@ -129,7 +129,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing) # scale the limits scale = axis[:scale] - sf = scale_func(scale) + sf = RecipesPipeline.scale_func(scale) # If the axis input was a Date or DateTime use a special logic to find # "round" Date(Time)s as ticks @@ -174,11 +174,11 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing) # chosen ticks is not too much bigger than amin - amax: strict_span = false, ) - axis[:lims] = map(inverse_scale_func(scale), (viewmin, viewmax)) + axis[:lims] = map(RecipesPipeline.inverse_scale_func(scale), (viewmin, viewmax)) else scaled_ticks = map(sf, (filter(t -> amin <= t <= amax, ticks))) end - unscaled_ticks = map(inverse_scale_func(scale), scaled_ticks) + unscaled_ticks = map(RecipesPipeline.inverse_scale_func(scale), scaled_ticks) labels = if any(isfinite, unscaled_ticks) formatter = axis[:formatter] @@ -378,7 +378,7 @@ function expand_extrema!(sp::Subplot, plotattributes::AKW) if fr === nothing && plotattributes[:seriestype] == :bar fr = 0.0 end - if fr !== nothing && !is3d(plotattributes) + if fr !== nothing && !RecipesPipeline.is3d(plotattributes) axis = sp.attr[vert ? :yaxis : :xaxis] if typeof(fr) <: Tuple for fri in fr @@ -423,7 +423,7 @@ end # push the limits out slightly function widen(lmin, lmax, scale = :identity) - f, invf = scale_func(scale), inverse_scale_func(scale) + f, invf = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale) span = f(lmax) - f(lmin) # eps = NaNMath.max(1e-16, min(1e-2span, 1e-10)) eps = NaNMath.max(1e-16, 0.03span) @@ -492,7 +492,7 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l amin, amax end - if !has_user_lims && consider_aspect && letter in (:x, :y) && !(sp[:aspect_ratio] in (:none, :auto) || is3d(:sp)) + if !has_user_lims && consider_aspect && letter in (:x, :y) && !(sp[:aspect_ratio] in (:none, :auto) || RecipesPipeline.is3d(:sp)) aspect_ratio = isa(sp[:aspect_ratio], Number) ? sp[:aspect_ratio] : 1 plot_ratio = height(plotarea(sp)) / width(plotarea(sp)) dist = amax - amin @@ -626,8 +626,8 @@ function axis_drawing_info(sp::Subplot) sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin, y2), (xmax, y2)) # top spine end if !(xaxis[:ticks] in (:none, nothing, false)) - f = scale_func(yaxis[:scale]) - invf = inverse_scale_func(yaxis[:scale]) + f = RecipesPipeline.scale_func(yaxis[:scale]) + invf = RecipesPipeline.inverse_scale_func(yaxis[:scale]) tick_start, tick_stop = if sp[:framestyle] == :origin t = invf(f(0) + 0.012 * (f(ymax) - f(ymin))) (-t, t) @@ -680,8 +680,8 @@ function axis_drawing_info(sp::Subplot) sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (x2, ymin), (x2, ymax)) # right spine end if !(yaxis[:ticks] in (:none, nothing, false)) - f = scale_func(xaxis[:scale]) - invf = inverse_scale_func(xaxis[:scale]) + f = RecipesPipeline.scale_func(xaxis[:scale]) + invf = RecipesPipeline.inverse_scale_func(xaxis[:scale]) tick_start, tick_stop = if sp[:framestyle] == :origin t = invf(f(0) + 0.012 * (f(xmax) - f(xmin))) (-t, t) @@ -772,8 +772,8 @@ function axis_drawing_info_3d(sp::Subplot) sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin, y2, z2), (xmax, y2, z2)) # top spine end if !(xaxis[:ticks] in (:none, nothing, false)) - f = scale_func(yaxis[:scale]) - invf = inverse_scale_func(yaxis[:scale]) + f = RecipesPipeline.scale_func(yaxis[:scale]) + invf = RecipesPipeline.inverse_scale_func(yaxis[:scale]) tick_start, tick_stop = if sp[:framestyle] == :origin t = invf(f(0) + 0.012 * (f(ymax) - f(ymin))) (-t, t) @@ -847,8 +847,8 @@ function axis_drawing_info_3d(sp::Subplot) sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (x2, ymin, z2), (x2, ymax, z2)) # right spine end if !(yaxis[:ticks] in (:none, nothing, false)) - f = scale_func(xaxis[:scale]) - invf = inverse_scale_func(xaxis[:scale]) + f = RecipesPipeline.scale_func(xaxis[:scale]) + invf = RecipesPipeline.inverse_scale_func(xaxis[:scale]) tick_start, tick_stop = if sp[:framestyle] == :origin t = invf(f(0) + 0.012 * (f(xmax) - f(xmin))) (-t, t) @@ -922,8 +922,8 @@ function axis_drawing_info_3d(sp::Subplot) sp[:framestyle] in (:semi, :box) && push!(zborder_segs, (x2, y2, zmin), (x2, y2, zmax)) end if !(zaxis[:ticks] in (:none, nothing, false)) - f = scale_func(xaxis[:scale]) - invf = inverse_scale_func(xaxis[:scale]) + f = RecipesPipeline.scale_func(xaxis[:scale]) + invf = RecipesPipeline.inverse_scale_func(xaxis[:scale]) tick_start, tick_stop = if sp[:framestyle] == :origin t = invf(f(0) + 0.012 * (f(ymax) - f(ymin))) (-t, t) diff --git a/src/backends.jl b/src/backends.jl index c8d6a2da..0cf036ae 100644 --- a/src/backends.jl +++ b/src/backends.jl @@ -104,7 +104,7 @@ end # Set the (left, top, right, bottom) minimum padding around the plot area # to fit ticks, tick labels, guides, colorbars, etc. function _update_min_padding!(sp::Subplot) - # TODO: something different when `is3d(sp) == true` + # TODO: something different when `RecipesPipeline.is3d(sp) == true` leftpad = tick_padding(sp, sp[:yaxis]) + sp[:left_margin] + guide_padding(sp[:yaxis]) toppad = sp[:top_margin] + title_padding(sp) rightpad = sp[:right_margin] diff --git a/src/backends/gr.jl b/src/backends/gr.jl index 3e1752d2..0f81c208 100644 --- a/src/backends/gr.jl +++ b/src/backends/gr.jl @@ -428,7 +428,7 @@ function gr_viewport_from_bbox(sp::Subplot{GRBackend}, bb::BoundingBox, w, h, vi viewport[3] = viewport_canvas[4] * (1.0 - bottom(bb) / h) viewport[4] = viewport_canvas[4] * (1.0 - top(bb) / h) if hascolorbar(sp) - viewport[2] -= gr_colorbar_ratio * (1 + is3d(sp) / 2) + viewport[2] -= gr_colorbar_ratio * (1 + RecipesPipeline.is3d(sp) / 2) end viewport end @@ -436,8 +436,8 @@ end # change so we're focused on the viewport area function gr_set_viewport_cmap(sp::Subplot) GR.setviewport( - viewport_plotarea[2] + (is3d(sp) ? 0.07 : 0.02), - viewport_plotarea[2] + (is3d(sp) ? 0.10 : 0.05), + viewport_plotarea[2] + (RecipesPipeline.is3d(sp) ? 0.07 : 0.02), + viewport_plotarea[2] + (RecipesPipeline.is3d(sp) ? 0.10 : 0.05), viewport_plotarea[3], viewport_plotarea[4] ) @@ -833,7 +833,7 @@ function _update_min_padding!(sp::Subplot{GRBackend}) toppad += h end - if is3d(sp) + if RecipesPipeline.is3d(sp) xaxis, yaxis, zaxis = sp[:xaxis], sp[:yaxis], sp[:zaxis] xticks, yticks, zticks = get_ticks(sp, xaxis), get_ticks(sp, yaxis), get_ticks(sp, zaxis) # Add margin for x and y ticks @@ -1053,7 +1053,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas) # fill in the plot area background bg = plot_color(sp[:background_color_inside]) - is3d(sp) || gr_fill_viewport(viewport_plotarea, bg) + RecipesPipeline.is3d(sp) || gr_fill_viewport(viewport_plotarea, bg) # reduced from before... set some flags based on the series in this subplot # TODO: can these be generic flags? @@ -1124,7 +1124,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas) gr_set_font(tickfont(xaxis)) GR.setlinewidth(sp.plt[:thickness_scaling]) - if is3d(sp) + if RecipesPipeline.is3d(sp) zmin, zmax = axis_limits(sp, :z) GR.setspace(zmin, zmax, round.(Int, sp[:camera])...) @@ -1135,7 +1135,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas) plot_area_x = [xmin, xmin, xmin, xmax, xmax, xmax, xmin] plot_area_y = [ymin, ymin, ymax, ymax, ymax, ymin, ymin] plot_area_z = [zmin, zmax, zmax, zmax, zmin, zmin, zmin] - x_bg, y_bg = unzip(GR.wc3towc.(plot_area_x, plot_area_y, plot_area_z)) + x_bg, y_bg = RecipesPipeline.unzip(GR.wc3towc.(plot_area_x, plot_area_y, plot_area_z)) GR.fillarea(x_bg, y_bg) # draw the grid lines @@ -1456,7 +1456,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas) GR.settextalign(halign, GR.TEXT_VALIGN_TOP) gr_text(xpos, viewport_subplot[4], sp[:title]) end - if is3d(sp) + if RecipesPipeline.is3d(sp) if xaxis[:guide] != "" gr_set_font( guidefont(xaxis), @@ -1713,7 +1713,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas) # draw markers if st == :scatter3d || series[:markershape] != :none - x2, y2 = unzip(map(GR.wc3towc, x, y, z)) + x2, y2 = RecipesPipeline.unzip(map(GR.wc3towc, x, y, z)) gr_draw_markers(series, x2, y2, clims) end @@ -1912,7 +1912,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas) end for ann in sp[:annotations] x, y, val = locate_annotation(sp, ann...) - x, y = if is3d(sp) + x, y = if RecipesPipeline.is3d(sp) gr_w3tondc(x, y, z) else GR.wctondc(x, y) diff --git a/src/backends/pgfplots.jl b/src/backends/pgfplots.jl index 276ad8dd..718d8241 100644 --- a/src/backends/pgfplots.jl +++ b/src/backends/pgfplots.jl @@ -166,7 +166,7 @@ function pgf_series(sp::Subplot, series::Series) # function args args = if st == :contour plotattributes[:z].surf, plotattributes[:x], plotattributes[:y] - elseif is3d(st) + elseif RecipesPipeline.is3d(st) plotattributes[:x], plotattributes[:y], plotattributes[:z] elseif st == :straightline straightline_data(series) @@ -271,7 +271,7 @@ function pgf_fillrange_series(series, i, fillrange, args...) push!(style, _pgf_series_extrastyle[st]) end kw[:style] = join(style, ',') - func = is3d(series) ? PGFPlots.Linear3 : PGFPlots.Linear + func = RecipesPipeline.is3d(series) ? PGFPlots.Linear3 : PGFPlots.Linear return func(pgf_fillrange_args(fillrange, args...)...; kw...) end @@ -444,7 +444,7 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend}) # add to style/kw for each axis for letter in (:x, :y, :z) - if letter != :z || is3d(sp) + if letter != :z || RecipesPipeline.is3d(sp) axisstyle, axiskw = pgf_axis(sp, letter) append!(style, axisstyle) merge!(kw, axiskw) @@ -494,7 +494,7 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend}) if any(s[:seriestype] == :contour for s in series_list(sp)) kw[:view] = "{0}{90}" kw[:colorbar] = !(sp[:colorbar] in (:none, :off, :hide, false)) - elseif is3d(sp) + elseif RecipesPipeline.is3d(sp) azim, elev = sp[:camera] kw[:view] = "{$(azim)}{$(elev)}" end diff --git a/src/backends/pgfplotsx.jl b/src/backends/pgfplotsx.jl index 1d596d3e..f2ddd84a 100644 --- a/src/backends/pgfplotsx.jl +++ b/src/backends/pgfplotsx.jl @@ -185,7 +185,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend}) ) end for letter in (:x, :y, :z) - if letter != :z || is3d(sp) + if letter != :z || RecipesPipeline.is3d(sp) pgfx_axis!(axis_opt, sp, letter) end end @@ -228,7 +228,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend}) "point meta min" => get_clims(sp)[1], ), ) - if is3d(sp) + if RecipesPipeline.is3d(sp) azim, elev = sp[:camera] push!(axis_opt, "view" => (azim, elev)) end @@ -251,7 +251,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend}) "color" => single_color(opt[:linecolor]), "name path" => string(series_id), ) - if is3d(series) || st == :heatmap + if RecipesPipeline.is3d(series) || st == :heatmap series_func = PGFPlotsX.Plot3 else series_func = PGFPlotsX.Plot @@ -422,7 +422,7 @@ end opt[:x], opt[:y], Array(opt[:z])' elseif st in (:heatmap, :surface, :wireframe) surface_to_vecs(opt[:x], opt[:y], opt[:z]) - elseif is3d(st) + elseif RecipesPipeline.is3d(st) opt[:x], opt[:y], opt[:z] elseif st == :straightline straightline_data(series) @@ -874,7 +874,7 @@ function pgfx_fillrange_series!(axis, series, series_func, i, fillrange, rng) fillrange_opt = merge(fillrange_opt, pgfx_marker(series, i)) push!(fillrange_opt, "forget plot" => nothing) opt = series.plotattributes - args = is3d(series) ? (opt[:x][rng], opt[:y][rng], opt[:z][rng]) : + args = RecipesPipeline.is3d(series) ? (opt[:x][rng], opt[:y][rng], opt[:z][rng]) : (opt[:x][rng], opt[:y][rng]) push!( axis, diff --git a/src/backends/plotly.jl b/src/backends/plotly.jl index 26a27f75..6b124fa9 100644 --- a/src/backends/plotly.jl +++ b/src/backends/plotly.jl @@ -162,7 +162,7 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot) if letter in (:x,:y) ax[:domain] = plotly_domain(sp, letter) - if is3d(sp) + if RecipesPipeline.is3d(sp) # don't link 3d axes for synchronized interactivity x_idx = y_idx = sp[:subplot_index] else @@ -263,8 +263,8 @@ function plotly_layout(plt::Plot) # set to supported framestyle sp[:framestyle] = _plotly_framestyle(sp[:framestyle]) - # if any(is3d, seriesargs) - if is3d(sp) + # if any(RecipesPipeline.is3d, seriesargs) + if RecipesPipeline.is3d(sp) azim = sp[:camera][1] - 90 #convert azimuthal to match GR behaviour theta = 90 - sp[:camera][2] #spherical coordinate angle from z axis plotattributes_out[:scene] = KW( @@ -748,11 +748,11 @@ function plotly_colorbar_hack(series::Series, plotattributes_base::KW, sym::Symb plotattributes_out = deepcopy(plotattributes_base) cmin, cmax = get_clims(series[:subplot]) plotattributes_out[:showlegend] = false - plotattributes_out[:type] = is3d(series) ? :scatter3d : :scatter + plotattributes_out[:type] = RecipesPipeline.is3d(series) ? :scatter3d : :scatter plotattributes_out[:hoverinfo] = :none plotattributes_out[:mode] = :markers plotattributes_out[:x], plotattributes_out[:y] = [series[:x][1]], [series[:y][1]] - if is3d(series) + if RecipesPipeline.is3d(series) plotattributes_out[:z] = [series[:z][1]] end # zrange = zmax == zmin ? 1 : zmax - zmin # if all marker_z values are the same, plot all markers same color (avoids division by zero in next line) diff --git a/src/backends/pyplot.jl b/src/backends/pyplot.jl index dc584e0d..2597eebe 100644 --- a/src/backends/pyplot.jl +++ b/src/backends/pyplot.jl @@ -448,7 +448,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series) # :norm => pycolors["Normalize"](; extrakw...) # ) # lz = _cycle(series[:line_z], 1:n) - # handle = if is3d(st) + # handle = if RecipesPipeline.is3d(st) # line_segments = [[(x[j], y[j], z[j]) for j in rng] for rng in segments] # lc = pyart3d["Line3DCollection"](line_segments; kw...) # lc[:set_array](lz) @@ -478,7 +478,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series) # end a = series[:arrow] - if a !== nothing && !is3d(st) # TODO: handle 3d later + if a !== nothing && !RecipesPipeline.is3d(st) # TODO: handle 3d later if typeof(a) != Arrow @warn("Unexpected type for arrow: $(typeof(a))") else @@ -1050,7 +1050,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend}) end # framestyle - if !ispolar(sp) && !is3d(sp) + if !ispolar(sp) && !RecipesPipeline.is3d(sp) ax.spines["left"]."set_linewidth"(py_thickness_scale(plt, 1)) ax.spines["bottom"]."set_linewidth"(py_thickness_scale(plt, 1)) if sp[:framestyle] == :semi @@ -1161,7 +1161,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend}) end #camera/view angle - if is3d(sp) + if RecipesPipeline.is3d(sp) #convert azimuthal to match GR behaviour #view_init(elevation, azimuthal) so reverse :camera args ax."view_init"((sp[:camera].-(90,0))[end:-1:1]...) diff --git a/src/backends/unicodeplots.jl b/src/backends/unicodeplots.jl index b0eb8b31..665ea411 100644 --- a/src/backends/unicodeplots.jl +++ b/src/backends/unicodeplots.jl @@ -126,7 +126,7 @@ function addUnicodeSeries!(o, plotattributes, addlegend::Bool, xlim, ylim) color = plotattributes[:linecolor] in UnicodePlots.color_cycle ? plotattributes[:linecolor] : :auto # add the series - x, y = Plots.unzip(collect(Base.Iterators.filter(xy->isfinite(xy[1])&&isfinite(xy[2]), zip(x,y)))) + x, y = RecipesPipeline.unzip(collect(Base.Iterators.filter(xy->isfinite(xy[1])&&isfinite(xy[2]), zip(x,y)))) func(o, x, y; color = color, name = label) end diff --git a/src/components.jl b/src/components.jl index fa657a4d..dfe0b633 100644 --- a/src/components.jl +++ b/src/components.jl @@ -29,7 +29,7 @@ end Construct a polygon to be plotted """ -Shape(verts::AVec) = Shape(unzip(verts)...) +Shape(verts::AVec) = Shape(RecipesPipeline.unzip(verts)...) Shape(s::Shape) = deepcopy(s) get_xs(shape::Shape) = shape.x diff --git a/src/pipeline.jl b/src/pipeline.jl index 2392877f..dbcd86f1 100644 --- a/src/pipeline.jl +++ b/src/pipeline.jl @@ -14,7 +14,7 @@ function RecipesPipeline.warn_on_recipe_aliases!( if k !== dk @warn "Attribute alias `$k` detected in the $recipe_type recipe defined for the signature $(_signature_string(Val{recipe_type}, args...)). To ensure expected behavior it is recommended to use the default attribute `$dk`." end - plotattributes[dk] = pop_kw!(plotattributes, k) + plotattributes[dk] = RecipesPipeline.pop_kw!(plotattributes, k) end end end @@ -57,7 +57,7 @@ end ## Preprocessing attributes RecipesPipeline.preprocess_attributes!(plt::Plot, plotattributes) = - preprocess_attributes!(plotattributes) # in src/args.jl + RecipesPipeline.preprocess_attributes!(plotattributes) # in src/args.jl RecipesPipeline.is_axis_attribute(plt::Plot, attr) = is_axis_attr_noletter(attr) # in src/args.jl @@ -298,7 +298,7 @@ function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where {T} st = _override_seriestype_check(plotattributes, st) # change to a 3d projection for this subplot? - if needs_3d_axes(st) + if RecipesPipeline.is_surface(st) sp.attr[:projection] = "3d" end @@ -312,7 +312,7 @@ end function _override_seriestype_check(plotattributes::AKW, st::Symbol) # do we want to override the series type? - if !is3d(st) && !(st in (:contour, :contour3d)) + if !RecipesPipeline.is3d(st) && !(st in (:contour, :contour3d)) z = plotattributes[:z] if !isa(z, Nothing) && (size(plotattributes[:x]) == size(plotattributes[:y]) == size(z)) diff --git a/src/plot.jl b/src/plot.jl index 3bd7e3ec..e52ac499 100644 --- a/src/plot.jl +++ b/src/plot.jl @@ -49,7 +49,7 @@ as a String to look up its docstring; e.g. `plotattr("seriestype")`. function plot(args...; kw...) # this creates a new plot with args/kw and sets it to be the current plot plotattributes = KW(kw) - preprocess_attributes!(plotattributes) + RecipesPipeline.preprocess_attributes!(plotattributes) # create an empty Plot then process plt = Plot() @@ -61,7 +61,7 @@ end # note: we split into plt1 and plts_tail so we can dispatch correctly function plot(plt1::Plot, plts_tail::Plot...; kw...) plotattributes = KW(kw) - preprocess_attributes!(plotattributes) + RecipesPipeline.preprocess_attributes!(plotattributes) # build our plot vector from the args n = length(plts_tail) + 1 @@ -153,7 +153,7 @@ end # this adds to a specific plot... most plot commands will flow through here function plot!(plt::Plot, args...; kw...) plotattributes = KW(kw) - preprocess_attributes!(plotattributes) + RecipesPipeline.preprocess_attributes!(plotattributes) # merge!(plt.user_attr, plotattributes) _plot!(plt, plotattributes, args) end @@ -212,5 +212,3 @@ function plot!(sp::Subplot, args...; kw...) plt = sp.plt plot!(plt, args...; kw..., subplot = findfirst(isequal(sp), plt.subplots)) end - -# -------------------------------------------------------------------- diff --git a/src/recipes.jl b/src/recipes.jl index 6fcea5ad..110aa461 100644 --- a/src/recipes.jl +++ b/src/recipes.jl @@ -458,7 +458,7 @@ end end @deps plots_heatmap shape is_3d(::Type{Val{:plots_heatmap}}) = true -is_surface(::Type{Val{:plots_heatmap}}) = true +RecipesPipeline.is_surface(::Type{Val{:plots_heatmap}}) = true # --------------------------------------------------------------------------- # Histograms @@ -1164,7 +1164,7 @@ function quiver_using_hack(plotattributes::AKW) ) end - plotattributes[:x], plotattributes[:y] = Plots.unzip(pts[2:end]) + plotattributes[:x], plotattributes[:y] = RecipesPipeline.unzip(pts[2:end]) # KW[plotattributes] end @@ -1283,13 +1283,13 @@ end # -------------------------------------------------------------------- # Lists of tuples and GeometryTypes.Points # -------------------------------------------------------------------- -@recipe f(v::AVec{<:GeometryTypes.Point}) = unzip(v) +@recipe f(v::AVec{<:GeometryTypes.Point}) = RecipesPipeline.unzip(v) @recipe f(p::GeometryTypes.Point) = [p] # Special case for 4-tuples in :ohlc series @recipe f(xyuv::AVec{<:Tuple{R1, R2, R3, R4}}) where {R1, R2, R3, R4} = get(plotattributes, :seriestype, :path) == :ohlc ? OHLC[OHLC(t...) for t in xyuv] : - unzip(xyuv) + RecipesPipeline.unzip(xyuv) # ------------------------------------------------- diff --git a/src/utils.jl b/src/utils.jl index bb6c5bd1..661b23bb 100644 --- a/src/utils.jl +++ b/src/utils.jl @@ -79,7 +79,7 @@ function iter_segments(series::Series) end else segs = UnitRange{Int}[] - args = is3d(series) ? (x, y, z) : (x, y) + args = RecipesPipeline.is3d(series) ? (x, y, z) : (x, y) for seg in iter_segments(args...) push!(segs, seg) end @@ -145,14 +145,14 @@ maketuple(x::Tuple{T,S}) where {T,S} = x for i in 2:4 @eval begin - unzip(v::Union{AVec{<:Tuple{Vararg{T,$i} where T}}, + RecipesPipeline.unzip(v::Union{AVec{<:Tuple{Vararg{T,$i} where T}}, AVec{<:GeometryTypes.Point{$i}}}) = $(Expr(:tuple, (:([t[$j] for t in v]) for j=1:i)...)) end end -unzip(v::Union{AVec{<:GeometryTypes.Point{N}}, +RecipesPipeline.unzip(v::Union{AVec{<:GeometryTypes.Point{N}}, AVec{<:Tuple{Vararg{T,N} where T}}}) where N = error("$N-dimensional unzip not implemented.") -unzip(v::Union{AVec{<:GeometryTypes.Point}, +RecipesPipeline.unzip(v::Union{AVec{<:GeometryTypes.Point}, AVec{<:Tuple}}) = error("Can't unzip points of different dimensions.") # given 2-element lims and a vector of data x, widen lims to account for the extrema of x @@ -187,7 +187,7 @@ end function replaceAlias!(plotattributes::AKW, k::Symbol, aliases::Dict{Symbol,Symbol}) if haskey(aliases, k) - plotattributes[aliases[k]] = pop_kw!(plotattributes, k) + plotattributes[aliases[k]] = RecipesPipeline.pop_kw!(plotattributes, k) end end @@ -226,7 +226,7 @@ end "create an (n+1) list of the outsides of heatmap rectangles" function heatmap_edges(v::AVec, scale::Symbol = :identity, isedges::Bool = false) - f, invf = scale_func(scale), inverse_scale_func(scale) + f, invf = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale) map(invf, _heatmap_edges(map(f,v), isedges)) end @@ -835,7 +835,7 @@ end function attr!(series::Series; kw...) plotattributes = KW(kw) - preprocess_attributes!(plotattributes) + RecipesPipeline.preprocess_attributes!(plotattributes) for (k,v) in plotattributes if haskey(_series_defaults, k) series[k] = v @@ -849,7 +849,7 @@ end function attr!(sp::Subplot; kw...) plotattributes = KW(kw) - preprocess_attributes!(plotattributes) + RecipesPipeline.preprocess_attributes!(plotattributes) for (k,v) in plotattributes if haskey(_subplot_defaults, k) sp[k] = v From 987456760c1f3c1a9689c7752b4ecca632e3c883 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Fri, 10 Apr 2020 19:22:45 +0200 Subject: [PATCH 15/17] update precompiles --- src/precompile.jl | 588 +++++----------------------------------------- 1 file changed, 57 insertions(+), 531 deletions(-) diff --git a/src/precompile.jl b/src/precompile.jl index 0b24d3bb..3e3a8d8f 100644 --- a/src/precompile.jl +++ b/src/precompile.jl @@ -6,7 +6,7 @@ function _precompile_() isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}}) isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{Symbol}}, typeof(Plots.attr!), Plots.Axis}) - isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{typeof(Plots.datetimeformatter)}}, typeof(Plots.attr!), Plots.Axis}) + isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{typeof(RecipesPipeline.datetimeformatter)}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Int64, Int64}, Bool}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :ticks), Tuple{Bool, Nothing}}, typeof(Plots.attr!), Plots.Axis}) @@ -47,493 +47,12 @@ function _precompile_() isdefined(Plots, Symbol("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:marker_z, :color, :legend), Tuple{typeof(Base.:+), Symbol, Bool}}, typeof(Plots.scatter), Array{Float64, 1}, Array{Float64, 1}}) isdefined(Plots, Symbol("#standalone_html##kw")) && precompile(Tuple{getfield(Plots, Symbol("#standalone_html##kw")), NamedTuple{(:title,), Tuple{String}}, typeof(Plots.standalone_html), Plots.Plot{Plots.PlotlyBackend}}) isdefined(Plots, Symbol("#test_examples##kw")) && precompile(Tuple{getfield(Plots, Symbol("#test_examples##kw")), NamedTuple{(:skip,), Tuple{Array{Int64, 1}}}, typeof(Plots.test_examples), Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{Float64, 1}, 1}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{T, 1} where T, 1}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Dates.DateTime, 1}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Function, 1}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Int64, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity), Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{Float64, 1}, Base.UnitRange{Int64}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{Float64, 1}, typeof(identity), Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{String, 1}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Array{String, 1}, Array{String, 1}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Base.StepRange{Int64, Int64}, Plots.RecipesPipeline.Surface{Array{Float64, 2}}, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Nothing, Array{Float64, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Nothing, Array{Union{Base.Missing, Float64}, 1}, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Nothing, Base.UnitRange{Int64}, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Nothing, Nothing, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._compute_xyz), Nothing, Plots.RecipesPipeline.Surface{Array{Float64, 2}}, Nothing}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy, typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipesPipeline.GroupBy}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._extract_group_attributes), Array{String, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._filter_input_data!), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._finish_userrecipe!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData}) - precompile(Tuple{typeof(Plots.RecipesPipeline._finish_userrecipe!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData}) - precompile(Tuple{typeof(Plots.RecipesPipeline._nobigs), Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._postprocess_axis_args!), Base.Dict{Symbol, Any}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Real, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._prepare_series_data), Array{Union{Base.Missing, Number}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._preprocess_axis_args!), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_fillrange), Int64, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_fillrange), Nothing, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_plotrecipe), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_plotrecipe), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_plotrecipes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_plotrecipes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_ribbon), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_ribbon), Int64, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_ribbon), Nothing, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_ribbon), Tuple{Base.LinRange{Float64}, Base.LinRange{Float64}}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_ribbon), typeof(identity), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_seriesrecipe), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_seriesrecipe), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_seriesrecipes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_seriesrecipes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._scaled_adapted_grid), typeof(identity), Symbol, Symbol, Float64, Float64}) - precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Array{Float64, 1}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Array{T, 1} where T, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Float64, 2}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Function, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Real, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Union{Base.Missing, Int64}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), Array{Union{Base.Missing, Number}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline._series_data_vector), typeof(identity), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.add_series!), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipesPipeline.add_series!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipesPipeline.filter_data!), Base.Dict{Symbol, Any}, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.filter_data), Array{Float64, 1}, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.filter_data), Base.OneTo{Int64}, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.filter_data), Nothing, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Array{Symbol, 2}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Plots.Subplot{Plots.GRBackend}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Plots.Subplot{Plots.PlotlyBackend}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Type{Base.Val{:contour}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Type{Base.Val{:heatmap}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Type{Base.Val{:path3d}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is3d), Type{Int}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is_axis_attribute), Plots.Plot{Plots.GRBackend}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is_axis_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is_seriestype_supported), Plots.Plot{Plots.GRBackend}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is_seriestype_supported), Plots.Plot{Plots.PlotlyBackend}, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is_surface), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is_surface), Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is_surface), Type{Base.Val{:contour}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is_surface), Type{Base.Val{:heatmap}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.is_surface), Type{Int}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.needs_3d_axes), Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.needs_3d_axes), Type{Base.Val{:path3d}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.needs_3d_axes), Type{Int}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.preprocess_attributes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.preprocess_attributes!), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipesPipeline.preprocess_attributes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.preprocess_attributes!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.RecipesPipeline.process_userrecipe!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.process_userrecipe!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.slice_series_attributes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.slice_series_attributes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{Int64, 1}, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{String, 1}, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{Symbol, 2}, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Plots.GridLayout, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Plots.Plot{Plots.GRBackend}, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, String, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Symbol, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{Int64, 1}, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{String, 1}, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{Symbol, 2}, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Plots.GridLayout, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Plots.Plot{Plots.PlotlyBackend}, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, String, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Symbol, Int64}) - precompile(Tuple{typeof(Plots.RecipesPipeline.unzip), Array{Tuple{Array{Float64, 1}, Array{Float64, 1}}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.unzip), Array{Tuple{Float64, Float64, Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Int64, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipesPipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipesPipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Int64, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipesPipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipesPipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipesPipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Base.Complex{Float64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Dates.DateTime, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 2}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Function, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{String, 1}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Tuple{Int64, Real}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Union{Base.Missing, Int64}, 1}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.StepRange{Int64, Int64}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Nothing, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.PortfolioComposition}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipesPipeline.Formatted{Array{Int64, 1}}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipesPipeline.GroupBy, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.Spy}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Type{Int}, Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, typeof(identity), Int}) - precompile(Tuple{typeof(Plots.RecipesPipeline.wrap_surfaces!), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.__init__)}) precompile(Tuple{typeof(Plots._add_errorbar_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots._add_markershape), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots._add_smooth_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots._backend_instance), Symbol}) precompile(Tuple{typeof(Plots._bin_centers), Array{Float64, 1}}) precompile(Tuple{typeof(Plots._binbarlike_baseline), Float64, Symbol}) @@ -570,15 +89,15 @@ function _precompile_() precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Bool}) precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Symbol}) precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.PlotlyBackend}, Bool}) - precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol}) - precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol}) + precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict, Symbol}) + precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict, Symbol}) precompile(Tuple{typeof(Plots._heatmap_edges), Array{Float64, 1}, Bool}) precompile(Tuple{typeof(Plots._hist_edge), Tuple{Array{Float64, 1}}, Int64, Symbol}) precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64}) precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}}) precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}}, Symbol}) precompile(Tuple{typeof(Plots._initialize_backend), Plots.PlotlyBackend}) - precompile(Tuple{typeof(Plots._override_seriestype_check), Plots.RecipesPipeline.DefaultsDict, Symbol}) + precompile(Tuple{typeof(Plots._override_seriestype_check), RecipesPipeline.DefaultsDict, Symbol}) precompile(Tuple{typeof(Plots._pick_default_backend)}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}}) @@ -636,24 +155,24 @@ function _precompile_() precompile(Tuple{typeof(Plots._plot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}}) precompile(Tuple{typeof(Plots._plotly_framestyle), Symbol}) precompile(Tuple{typeof(Plots._plots_defaults)}) - precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipesPipeline.DefaultsDict, Array{Float64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipesPipeline.DefaultsDict, Array{Int64, 1}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipesPipeline.DefaultsDict, Base.OneTo{Int64}, Array{Float64, 1}}) - precompile(Tuple{typeof(Plots._preprocess_binlike), Plots.RecipesPipeline.DefaultsDict, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._preprocess_barlike), RecipesPipeline.DefaultsDict, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._preprocess_barlike), RecipesPipeline.DefaultsDict, Array{Int64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._preprocess_barlike), RecipesPipeline.DefaultsDict, Base.OneTo{Int64}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots._preprocess_binlike), RecipesPipeline.DefaultsDict, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}) precompile(Tuple{typeof(Plots._preprocess_userrecipe), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._replace_linewidth), Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._replace_linewidth), RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots._replace_markershape), Array{Symbol, 2}}) precompile(Tuple{typeof(Plots._replace_markershape), Plots.Shape}) precompile(Tuple{typeof(Plots._scale_adjusted_values), Type{Float64}, Array{Float64, 1}, Symbol}) - precompile(Tuple{typeof(Plots._series_index), Plots.RecipesPipeline.DefaultsDict, Plots.Subplot{Plots.GRBackend}}) - precompile(Tuple{typeof(Plots._series_index), Plots.RecipesPipeline.DefaultsDict, Plots.Subplot{Plots.PlotlyBackend}}) + precompile(Tuple{typeof(Plots._series_index), RecipesPipeline.DefaultsDict, Plots.Subplot{Plots.GRBackend}}) + precompile(Tuple{typeof(Plots._series_index), RecipesPipeline.DefaultsDict, Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._show), Base.IOStream, Base.Multimedia.MIME{Symbol("image/png")}, Plots.Plot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64}) precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64}) - precompile(Tuple{typeof(Plots._slice_series_args!), Plots.RecipesPipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64}) - precompile(Tuple{typeof(Plots._slice_series_args!), Plots.RecipesPipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64}) + precompile(Tuple{typeof(Plots._slice_series_args!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64}) + precompile(Tuple{typeof(Plots._slice_series_args!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64}) precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}}) precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}}) precompile(Tuple{typeof(Plots._transform_ticks), Base.StepRange{Int64, Int64}}) @@ -661,11 +180,11 @@ function _precompile_() precompile(Tuple{typeof(Plots._transform_ticks), Nothing}) precompile(Tuple{typeof(Plots._transform_ticks), Symbol}) precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Base.Dict{Symbol, Any}, Symbol, Int64}) - precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Plots.RecipesPipeline.DefaultsDict, Symbol, Int64}) + precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, RecipesPipeline.DefaultsDict, Symbol, Int64}) precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64}) - precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol, Int64}) + precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict, Symbol, Int64}) precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Int64}) - precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict, Symbol, Int64}) + precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict, Symbol, Int64}) precompile(Tuple{typeof(Plots._update_axis_colors), Plots.Axis}) precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.GRBackend}, Plots.Axis, Symbol}) precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.PlotlyBackend}, Plots.Axis, Symbol}) @@ -675,22 +194,22 @@ function _precompile_() precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.RecipesPipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}}) - precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.RecipesPipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}}) + precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots._update_series_attributes!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}}) + precompile(Tuple{typeof(Plots._update_series_attributes!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Int64, Bool}) - precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict, Int64, Bool}) + precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict, Int64, Bool}) precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Int64, Bool}) - precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict, Int64, Bool}) + precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict, Int64, Bool}) precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.GRBackend}, Array{Any, 1}}) precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.PlotlyBackend}, Array{Any, 1}}) precompile(Tuple{typeof(Plots.addExtension), String, String}) precompile(Tuple{typeof(Plots.add_layout_pct!), Base.Dict{Symbol, Any}, Expr, Int64, Int64}) - precompile(Tuple{typeof(Plots.aliasesAndAutopick), Plots.RecipesPipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64}) + precompile(Tuple{typeof(Plots.aliasesAndAutopick), RecipesPipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64}) precompile(Tuple{typeof(Plots.allAlphas), Int64}) precompile(Tuple{typeof(Plots.allStyles), Int64}) precompile(Tuple{typeof(Plots.allStyles), Symbol}) @@ -724,10 +243,10 @@ function _precompile_() precompile(Tuple{typeof(Plots.bottompad), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64, Array{Plots.Plot{T} where T<:RecipesBase.AbstractBackend, 1}}) precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64}) - precompile(Tuple{typeof(Plots.build_layout), Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.build_layout), RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.EmptyLayout}) precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.GridLayout}) - precompile(Tuple{typeof(Plots.color_or_nothing!), Plots.RecipesPipeline.DefaultsDict, Symbol}) + precompile(Tuple{typeof(Plots.color_or_nothing!), RecipesPipeline.DefaultsDict, Symbol}) precompile(Tuple{typeof(Plots.colorbar_style), Plots.Series}) precompile(Tuple{typeof(Plots.compute_gridsize), Int64, Int64, Int64}) precompile(Tuple{typeof(Plots.concatenate_fillrange), Base.UnitRange{Int64}, Tuple{Array{Float64, 1}, Array{Float64, 1}}}) @@ -753,7 +272,11 @@ function _precompile_() precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Base.Missing}) precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Char}) precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, String}) - precompile(Tuple{typeof(Plots.ensure_gradient!), Plots.RecipesPipeline.DefaultsDict, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.ensure_gradient!), RecipesPipeline.DefaultsDict, Symbol, Symbol}) + precompile(Tuple{typeof(Plots.error_coords), Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.error_coords), Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}) + precompile(Tuple{typeof(Plots.error_style!), RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.error_zipit), Array{Float64, 1}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Float64, 1}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Int64, 1}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.OneTo{Int64}}) @@ -762,14 +285,14 @@ function _precompile_() precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.UnitRange{Int64}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Float64}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Int64}) - precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, RecipesPipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Tuple{Float64, Float64}}) - precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.extend_by_data!), Array{Float64, 1}, Float64}) precompile(Tuple{typeof(Plots.extend_series_data!), Plots.Series, Float64, Symbol}) precompile(Tuple{typeof(Plots.fakedata), Int64, Int64}) - precompile(Tuple{typeof(Plots.fg_color), Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.fg_color), RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.font), Int64, Int}) precompile(Tuple{typeof(Plots.font), String, Int}) precompile(Tuple{typeof(Plots.font), Symbol, Int}) @@ -871,6 +394,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.gr_set_markercolor), ColorTypes.RGBA{Float64}}) precompile(Tuple{typeof(Plots.gr_set_textcolor), ColorTypes.RGBA{Float64}}) precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Float64}) + precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Int64}) precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Nothing}) precompile(Tuple{typeof(Plots.gr_set_transparency), Float64}) precompile(Tuple{typeof(Plots.gr_set_viewport_cmap), Plots.Subplot{Plots.GRBackend}}) @@ -884,6 +408,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.gr_update_colorbar!), Plots.GRColorbar, Plots.Series}) precompile(Tuple{typeof(Plots.gr_viewport_from_bbox), Plots.Subplot{Plots.GRBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Array{Float64, 1}}) precompile(Tuple{typeof(Plots.gr_w3tondc), Float64, Float64, Float64}) + precompile(Tuple{typeof(Plots.gr_w3tondc), Int64, Float64, Float64}) precompile(Tuple{typeof(Plots.gui), Plots.Plot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.gui), Plots.Plot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.guide_padding), Plots.Axis}) @@ -948,7 +473,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.isvertical), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.isvertical), Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.isvertical), RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}, Int}) precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}}) precompile(Tuple{typeof(Plots.iter_segments), Array{Int64, 1}, Array{Float64, 1}}) @@ -966,7 +491,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.layout_args), Int64, Tuple{Int64, Int64}}) precompile(Tuple{typeof(Plots.layout_args), Int64}) precompile(Tuple{typeof(Plots.layout_args), Plots.GridLayout}) - precompile(Tuple{typeof(Plots.layout_args), Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.layout_args), RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}}) precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}) precompile(Tuple{typeof(Plots.leftpad), Plots.Subplot{Plots.GRBackend}}) @@ -977,6 +502,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.like_histogram), Symbol}) precompile(Tuple{typeof(Plots.link_axes!), Array{RecipesBase.AbstractLayout, 1}, Symbol}) precompile(Tuple{typeof(Plots.link_axes!), Plots.Axis, Plots.Axis}) + precompile(Tuple{typeof(Plots.link_axes!), Plots.Axis}) precompile(Tuple{typeof(Plots.link_axes!), Plots.GridLayout, Symbol}) precompile(Tuple{typeof(Plots.link_axes!), Plots.Subplot{Plots.GRBackend}, Symbol}) precompile(Tuple{typeof(Plots.link_axes!), Plots.Subplot{Plots.PlotlyBackend}, Symbol}) @@ -1022,7 +548,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.StepRange{Int64, Int64}}) precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.UnitRange{Int64}}) precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Nothing}) - precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, RecipesPipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.plotly_domain), Plots.Subplot{Plots.PlotlyBackend}, Symbol}) precompile(Tuple{typeof(Plots.plotly_font), Plots.Font, ColorTypes.RGBA{Float64}}) precompile(Tuple{typeof(Plots.plotly_font), Plots.Font}) @@ -1041,11 +567,12 @@ function _precompile_() precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}) precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRange{Int64, Int64}}) precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.UnitRange{Int64}}) - precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, RecipesPipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.plotly_polar!), Base.Dict{Symbol, Any}, Plots.Series}) precompile(Tuple{typeof(Plots.plotly_polaraxis), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis}) precompile(Tuple{typeof(Plots.plotly_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Series}) precompile(Tuple{typeof(Plots.plotly_series), Plots.Plot{Plots.PlotlyBackend}}) + precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}}) precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Float64, 1}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}}) precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Int64, 1}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}}) precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Int64, 1}, Array{Int64, 1}, Nothing, Tuple{Float64, Float64}}) @@ -1056,12 +583,10 @@ function _precompile_() precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.UnitRange{Int64}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}}) precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Nothing, Nothing, Nothing, Tuple{Float64, Float64}}) precompile(Tuple{typeof(Plots.plotly_series_shapes), Plots.Plot{Plots.PlotlyBackend}, Plots.Series, Tuple{Float64, Float64}}) - precompile(Tuple{typeof(Plots.plotly_surface_data), Plots.Series, Plots.RecipesPipeline.Surface{Array{Float64, 2}}}) + precompile(Tuple{typeof(Plots.plotly_surface_data), Plots.Series, RecipesPipeline.Surface{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots.png), Plots.Plot{Plots.GRBackend}, String}) precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.GRBackend}}) precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.PlotlyBackend}}) - precompile(Tuple{typeof(Plots.preprocess_attributes!), Base.Dict{Symbol, Any}}) - precompile(Tuple{typeof(Plots.preprocess_attributes!), Plots.RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Bool}) precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Int64}) precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol}) @@ -1072,7 +597,7 @@ function _precompile_() precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Float64, Symbol}) precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Int64, Symbol}) precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Symbol, Symbol}) - precompile(Tuple{typeof(Plots.processGridArg!), Plots.RecipesPipeline.DefaultsDict, Bool, Symbol}) + precompile(Tuple{typeof(Plots.processGridArg!), RecipesPipeline.DefaultsDict, Bool, Symbol}) precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Array{Symbol, 2}}) precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Float64}) precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Int64}) @@ -1096,9 +621,9 @@ function _precompile_() precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, Tuple{Int64, Int64}, Symbol}) precompile(Tuple{typeof(Plots.recompute_lengths), Array{Measures.Measure, 1}}) precompile(Tuple{typeof(Plots.replaceAlias!), Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Symbol}}) - precompile(Tuple{typeof(Plots.replaceAlias!), Plots.RecipesPipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}}) + precompile(Tuple{typeof(Plots.replaceAlias!), RecipesPipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}}) precompile(Tuple{typeof(Plots.replaceAliases!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Symbol}}) - precompile(Tuple{typeof(Plots.replaceAliases!), Plots.RecipesPipeline.DefaultsDict, Base.Dict{Symbol, Symbol}}) + precompile(Tuple{typeof(Plots.replaceAliases!), RecipesPipeline.DefaultsDict, Base.Dict{Symbol, Symbol}}) precompile(Tuple{typeof(Plots.reset_axis_defaults_byletter!)}) precompile(Tuple{typeof(Plots.right), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}}) precompile(Tuple{typeof(Plots.rightpad), Plots.Subplot{Plots.GRBackend}}) @@ -1114,9 +639,10 @@ function _precompile_() precompile(Tuple{typeof(Plots.showaxis), Symbol, Symbol}) precompile(Tuple{typeof(Plots.shrink_by), Float64, Float64, Float64}) precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Int64, Bool}) - precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Plots.RecipesPipeline.DefaultsDict, Symbol, Int64, Bool}) - precompile(Tuple{typeof(Plots.slice_arg!), Plots.RecipesPipeline.DefaultsDict, Plots.RecipesPipeline.DefaultsDict, Symbol, Int64, Bool}) + precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, RecipesPipeline.DefaultsDict, Symbol, Int64, Bool}) + precompile(Tuple{typeof(Plots.slice_arg!), RecipesPipeline.DefaultsDict, RecipesPipeline.DefaultsDict, Symbol, Int64, Bool}) precompile(Tuple{typeof(Plots.slice_arg), Array{ColorTypes.RGBA{Float64}, 2}, Int64}) + precompile(Tuple{typeof(Plots.slice_arg), Array{Float64, 2}, Int64}) precompile(Tuple{typeof(Plots.slice_arg), Array{Measures.Length{:mm, Float64}, 2}, Int64}) precompile(Tuple{typeof(Plots.slice_arg), Array{String, 2}, Int64}) precompile(Tuple{typeof(Plots.slice_arg), Array{Symbol, 2}, Int64}) @@ -1167,10 +693,10 @@ function _precompile_() precompile(Tuple{typeof(Plots.update_inset_bboxes!), Plots.Plot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots.vline!), Array{Int64, 1}}) precompile(Tuple{typeof(Plots.wand_edges), Array{Float64, 1}}) - precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.GRBackend, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.PlotlyBackend, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.GRBackend, Plots.RecipesPipeline.DefaultsDict}) - precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.PlotlyBackend, Plots.RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.GRBackend, RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.PlotlyBackend, RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.GRBackend, RecipesPipeline.DefaultsDict}) + precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.PlotlyBackend, RecipesPipeline.DefaultsDict}) precompile(Tuple{typeof(Plots.warn_on_unsupported_scales), Plots.GRBackend, Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.warn_on_unsupported_scales), Plots.PlotlyBackend, Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.widen), Float64, Float64, Symbol}) From 848b53e7d7f1d1b645b755a5ca22ef27fc8432b9 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Fri, 10 Apr 2020 19:45:11 +0200 Subject: [PATCH 16/17] fix 3d plots --- src/pipeline.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pipeline.jl b/src/pipeline.jl index dbcd86f1..c7be171f 100644 --- a/src/pipeline.jl +++ b/src/pipeline.jl @@ -298,7 +298,7 @@ function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where {T} st = _override_seriestype_check(plotattributes, st) # change to a 3d projection for this subplot? - if RecipesPipeline.is_surface(st) + if RecipesPipeline.needs_3d_axes(st) sp.attr[:projection] = "3d" end From a1cd3d8f9523ce78b160b5cbc2cf8a2cb6f0a836 Mon Sep 17 00:00:00 2001 From: Daniel Schwabeneder Date: Fri, 10 Apr 2020 19:47:09 +0200 Subject: [PATCH 17/17] don't require julia 1.1 --- .travis.yml | 2 +- Project.toml | 4 ++-- appveyor.yml | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index 9fac2036..ccd58dfb 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,7 +4,7 @@ os: - linux # - osx julia: - - 1.1 + - 1.0 - 1 - nightly diff --git a/Project.toml b/Project.toml index 967c74db..32f7adf9 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,7 @@ name = "Plots" uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" author = ["Tom Breloff (@tbreloff)"] -version = "1.1.0" +version = "1.0.8" [deps] Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" @@ -49,7 +49,7 @@ Reexport = "0.2" Requires = "0.5, 1" Showoff = "0.3.1" StatsBase = "0.32, 0.33" -julia = "1.1" +julia = "1" [extras] FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" diff --git a/appveyor.yml b/appveyor.yml index ca9c454d..081e56df 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,6 +1,6 @@ environment: matrix: - - julia_version: 1.1 + - julia_version: 1.0 - julia_version: 1 - julia_version: nightly