mantao/Plots.jl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #2524 from daschw/surface-type-recipe

Browse Source 
Apply type recipes also for plots with surfaces
This commit is contained in:
Daniel Schwabeneder 2020-04-01 19:45:10 +02:00 committed by GitHub
commit efdfec13ed
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 329 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/components.jl
View File

@ -663,8 +663,8 @@ Surface(f::Function, x, y) = Surface(Float64[f(xi,yi) for yi in y, xi in x])
Base.Array(surf::Surface) = surf.surf Base.Array(surf::Surface) = surf.surf
for f in (:length, :size) for f in (:length, :size, :axes)
@eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...) @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
end end
Base.copy(surf::Surface) = Surface(copy(surf.surf)) Base.copy(surf::Surface) = Surface(copy(surf.surf))
Base.eltype(surf::Surface{T}) where {T} = eltype(T) Base.eltype(surf::Surface{T}) where {T} = eltype(T)

15
src/examples.jl
View File

@ -919,6 +919,21 @@ const _examples = PlotExample[
end, end,
], ],
), ),
PlotExample(
"Heatmap with DateTime axis",
"",
[
quote
begin
using Dates
z = rand(5, 5)
x = DateTime.(2016:2020)
y = 1:5
heatmap(x, y, z)
end
end,
],
),
] ]
# Some constants for PlotDocs and PlotReferenceImages # Some constants for PlotDocs and PlotReferenceImages

12
src/pipeline.jl
View File

@ -10,10 +10,12 @@ function warn_on_recipe_aliases!(plotattributes, recipe_type, args...)
end end
end end
end end
warn_on_recipe_aliases!(v::AbstractVector, recipe_type, args) = function warn_on_recipe_aliases!(v::AbstractVector, recipe_type, args...)
foreach(x -> warn_on_recipe_aliases!(x, recipe_type, args), v) foreach(x -> warn_on_recipe_aliases!(x, recipe_type, args...), v)
warn_on_recipe_aliases!(rd::RecipeData, recipe_type, args) = end
warn_on_recipe_aliases!(rd.plotattributes, recipe_type, args) function warn_on_recipe_aliases!(rd::RecipeData, recipe_type, args...)
warn_on_recipe_aliases!(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)), ", ::"), ")") return string("(::", join(string.(typeof.(args)), ", ::"), ")")
@ -102,7 +104,7 @@ function _process_userrecipes(plt::Plot, plotattributes::AKW, args)
next_series.plotattributes, next_series.plotattributes,
next_series.args... next_series.args...
) )
warn_on_recipe_aliases!(rd_list, :user, 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
end end

208
src/precompile.jl
View File

@ -5,12 +5,12 @@ 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}}, 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}, Array{Float64, 1}}, 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}, 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}, 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("#_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{(:foreground_color_grid, :grid, :gridalpha, :gridstyle, :gridlinewidth), Tuple{ColorTypes.RGBA{Float64}, Bool, Float64, Symbol, Int64}}, typeof(Plots.attr!), Plots.Axis})
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{Symbol}}, 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), 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, :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}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :ticks), Tuple{Bool, Nothing}}, typeof(Plots.attr!), Plots.Axis})
isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid,), Tuple{Bool}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid,), Tuple{Bool}}, typeof(Plots.attr!), Plots.Axis})
isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, ColorTypes.RGBA{Float64}}}, typeof(Plots.attr!), Plots.Axis})
isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:guide,), Tuple{String}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:guide,), Tuple{String}}, typeof(Plots.attr!), Plots.Axis})
isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, Base.StepRange{Int64, Int64}, String}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, Base.StepRange{Int64, Int64}, String}}, typeof(Plots.attr!), Plots.Axis})
isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
@ -21,6 +21,7 @@ function _precompile_()
isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:ticks,), Tuple{Base.UnitRange{Int64}}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:ticks,), Tuple{Base.UnitRange{Int64}}}, typeof(Plots.attr!), Plots.Axis})
isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:ticks,), Tuple{Nothing}}, typeof(Plots.attr!), Plots.Axis}) isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:ticks,), Tuple{Nothing}}, typeof(Plots.attr!), Plots.Axis})
isdefined(Plots, Symbol("#contour##kw")) && precompile(Tuple{getfield(Plots, Symbol("#contour##kw")), NamedTuple{(:fill,), Tuple{Bool}}, typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int}) isdefined(Plots, Symbol("#contour##kw")) && precompile(Tuple{getfield(Plots, Symbol("#contour##kw")), NamedTuple{(:fill,), Tuple{Bool}}, typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
isdefined(Plots, Symbol("#default##kw")) && precompile(Tuple{getfield(Plots, Symbol("#default##kw")), NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}}, typeof(Plots.default)})
isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}}) isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}})
isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Int64, 1}, Array{Float64, 1}}) isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Int64, 1}, Array{Float64, 1}})
isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}) isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
@ -54,9 +55,12 @@ function _precompile_()
precompile(Tuple{typeof(Plots._add_smooth_kw), Array{Base.Dict{Symbol, Any}, 1}, 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.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._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{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{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}, 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._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity), Symbol})
precompile(Tuple{typeof(Plots._backend_instance), Symbol}) precompile(Tuple{typeof(Plots._backend_instance), Symbol})
precompile(Tuple{typeof(Plots._bin_centers), Array{Float64, 1}}) precompile(Tuple{typeof(Plots._bin_centers), Array{Float64, 1}})
@ -103,6 +107,7 @@ function _precompile_()
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, 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{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}, 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{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}, 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{Int64, 1}}})
@ -125,6 +130,7 @@ function _precompile_()
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, 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{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}, 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{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}, 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{Int64, 1}}})
@ -166,6 +172,7 @@ function _precompile_()
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
@ -190,6 +197,7 @@ function _precompile_()
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}, 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, 1}}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}}) precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
@ -223,6 +231,7 @@ function _precompile_()
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, 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{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}, 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{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{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{Int64, 1}}, Array{RecipesBase.RecipeData, 1}})
@ -261,6 +270,7 @@ function _precompile_()
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, 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{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}, 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{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}, 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{Int64, 1}}})
@ -285,6 +295,7 @@ function _precompile_()
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}, 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, 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{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}, 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{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{Plots.OHLC{T} where T<:Real, 1}}})
@ -304,6 +315,7 @@ function _precompile_()
precompile(Tuple{typeof(Plots._replace_markershape), Array{Symbol, 2}}) precompile(Tuple{typeof(Plots._replace_markershape), Array{Symbol, 2}})
precompile(Tuple{typeof(Plots._replace_markershape), Plots.Shape}) 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._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.GRBackend}})
precompile(Tuple{typeof(Plots._series_index), Plots.Attr, Plots.Subplot{Plots.PlotlyBackend}}) precompile(Tuple{typeof(Plots._series_index), Plots.Attr, 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._show), Base.IOStream, Base.Multimedia.MIME{Symbol("image/png")}, Plots.Plot{Plots.GRBackend}})
@ -356,7 +368,6 @@ function _precompile_()
precompile(Tuple{typeof(Plots.annotate!), Array{Tuple{Int64, Float64, Plots.PlotText}, 1}}) precompile(Tuple{typeof(Plots.annotate!), Array{Tuple{Int64, Float64, Plots.PlotText}, 1}})
precompile(Tuple{typeof(Plots.annotations), Array{Any, 1}}) precompile(Tuple{typeof(Plots.annotations), Array{Any, 1}})
precompile(Tuple{typeof(Plots.arrow), Int64}) precompile(Tuple{typeof(Plots.arrow), Int64})
precompile(Tuple{typeof(Plots.attr!), Plots.Axis})
precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol, Symbol}) precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol, Symbol})
precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol}) precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol})
precompile(Tuple{typeof(Plots.autopick), Array{ColorTypes.RGBA{Float64}, 1}, Int64}) precompile(Tuple{typeof(Plots.autopick), Array{ColorTypes.RGBA{Float64}, 1}, Int64})
@ -419,6 +430,10 @@ function _precompile_()
precompile(Tuple{typeof(Plots.create_grid), Symbol}) precompile(Tuple{typeof(Plots.create_grid), Symbol})
precompile(Tuple{typeof(Plots.create_grid_curly), Expr}) precompile(Tuple{typeof(Plots.create_grid_curly), Expr})
precompile(Tuple{typeof(Plots.create_grid_vcat), Expr}) precompile(Tuple{typeof(Plots.create_grid_vcat), Expr})
precompile(Tuple{typeof(Plots.default), Symbol, Bool})
precompile(Tuple{typeof(Plots.default), Symbol, Int64})
precompile(Tuple{typeof(Plots.default), Symbol, String})
precompile(Tuple{typeof(Plots.default), Symbol, Symbol})
precompile(Tuple{typeof(Plots.default), Symbol}) precompile(Tuple{typeof(Plots.default), Symbol})
precompile(Tuple{typeof(Plots.default_should_widen), Plots.Axis}) precompile(Tuple{typeof(Plots.default_should_widen), Plots.Axis})
precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Array{String, 1}}) precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Array{String, 1}})
@ -601,6 +616,8 @@ function _precompile_()
precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Int64}}) precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Int64}})
precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}}) precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}})
precompile(Tuple{typeof(Plots.is_axis_attr), Symbol}) precompile(Tuple{typeof(Plots.is_axis_attr), Symbol})
precompile(Tuple{typeof(Plots.is_axis_attr_noletter), Symbol})
precompile(Tuple{typeof(Plots.is_default_attribute), Symbol})
precompile(Tuple{typeof(Plots.is_marker_supported), Plots.GRBackend, Symbol}) precompile(Tuple{typeof(Plots.is_marker_supported), Plots.GRBackend, Symbol})
precompile(Tuple{typeof(Plots.is_marker_supported), Plots.PlotlyBackend, Symbol}) precompile(Tuple{typeof(Plots.is_marker_supported), Plots.PlotlyBackend, Symbol})
precompile(Tuple{typeof(Plots.is_marker_supported), Plots.Shape}) precompile(Tuple{typeof(Plots.is_marker_supported), Plots.Shape})
@ -608,11 +625,13 @@ function _precompile_()
precompile(Tuple{typeof(Plots.is_marker_supported), Symbol}) precompile(Tuple{typeof(Plots.is_marker_supported), Symbol})
precompile(Tuple{typeof(Plots.is_scale_supported), Plots.GRBackend, Symbol}) precompile(Tuple{typeof(Plots.is_scale_supported), Plots.GRBackend, Symbol})
precompile(Tuple{typeof(Plots.is_scale_supported), Plots.PlotlyBackend, Symbol}) precompile(Tuple{typeof(Plots.is_scale_supported), Plots.PlotlyBackend, Symbol})
precompile(Tuple{typeof(Plots.is_series_attr), Symbol})
precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.GRBackend, Symbol}) precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.GRBackend, Symbol})
precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.PlotlyBackend, Symbol}) precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.PlotlyBackend, Symbol})
precompile(Tuple{typeof(Plots.is_seriestype_supported), Symbol}) precompile(Tuple{typeof(Plots.is_seriestype_supported), Symbol})
precompile(Tuple{typeof(Plots.is_style_supported), Plots.GRBackend, Symbol}) precompile(Tuple{typeof(Plots.is_style_supported), Plots.GRBackend, Symbol})
precompile(Tuple{typeof(Plots.is_style_supported), Plots.PlotlyBackend, Symbol}) precompile(Tuple{typeof(Plots.is_style_supported), Plots.PlotlyBackend, Symbol})
precompile(Tuple{typeof(Plots.is_subplot_attr), Symbol})
precompile(Tuple{typeof(Plots.is_uniformly_spaced), Array{Float64, 1}}) precompile(Tuple{typeof(Plots.is_uniformly_spaced), Array{Float64, 1}})
precompile(Tuple{typeof(Plots.iscontour), Plots.Series}) precompile(Tuple{typeof(Plots.iscontour), Plots.Series})
precompile(Tuple{typeof(Plots.isijulia)}) precompile(Tuple{typeof(Plots.isijulia)})
@ -671,7 +690,6 @@ function _precompile_()
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.StepRange{Int64, Int64}})
precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Base.UnitRange{Int64}}) precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Nothing}) precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Nothing})
precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Base.StepRange{Int64, Int64}})
precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Base.UnitRange{Int64}}) precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Nothing}) precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Nothing})
precompile(Tuple{typeof(Plots.parse_axis_kw), Symbol}) precompile(Tuple{typeof(Plots.parse_axis_kw), Symbol})
@ -747,6 +765,9 @@ function _precompile_()
precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Bool}) 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}, Int64})
precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol}) precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol})
precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, Int64})
precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, String})
precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, Symbol})
precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Bool, Symbol}) precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Bool, Symbol})
precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Float64, Symbol}) 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}, Int64, Symbol})
@ -764,6 +785,7 @@ function _precompile_()
precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Plots.Shape}) precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Plots.Shape})
precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Plots.Stroke}) precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Plots.Stroke})
precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Symbol}) precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Symbol})
precompile(Tuple{typeof(Plots.processMinorGridArg!), Base.Dict{Symbol, Any}, Bool, Symbol})
precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText, Plots.Font}) precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText, Plots.Font})
precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText}) precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText})
precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.PlotlyBackend}, Int64, Float64, Plots.PlotText, Plots.Font}) precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.PlotlyBackend}, Int64, Float64, Plots.PlotText, Plots.Font})
@ -794,6 +816,7 @@ function _precompile_()
precompile(Tuple{typeof(Plots.series_annotations), Plots.SeriesAnnotations}) precompile(Tuple{typeof(Plots.series_annotations), Plots.SeriesAnnotations})
precompile(Tuple{typeof(Plots.series_annotations_shapes!), Plots.Series, Symbol}) 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_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{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{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{Float64, 2}, Base.Dict{Symbol, Any}})
@ -878,8 +901,184 @@ function _precompile_()
precompile(Tuple{typeof(Plots.warnOnUnsupported_args), Plots.PlotlyBackend, 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.GRBackend, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(Plots.warnOnUnsupported_scales), Plots.PlotlyBackend, 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.widen), Float64, Float64, Symbol}) precompile(Tuple{typeof(Plots.widen), Float64, Float64, Symbol})
precompile(Tuple{typeof(Plots.wrap_surfaces), Base.Dict{Symbol, Any}}) precompile(Tuple{typeof(Plots.wrap_surfaces!), Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(Plots.wraptuple), Array{Any, 1}}) precompile(Tuple{typeof(Plots.wraptuple), Array{Any, 1}})
precompile(Tuple{typeof(Plots.wraptuple), Array{Float64, 1}}) precompile(Tuple{typeof(Plots.wraptuple), Array{Float64, 1}})
precompile(Tuple{typeof(Plots.wraptuple), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}) precompile(Tuple{typeof(Plots.wraptuple), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
@ -894,6 +1093,7 @@ function _precompile_()
precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Array{Symbol, 2}}}) precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Array{Symbol, 2}}})
precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Float64, Symbol, Plots.Stroke}}) precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Float64, Symbol, Plots.Stroke}})
precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Float64, Symbol}}) precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Float64, Symbol}})
precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, String}})
precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}}) precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}})
precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol, Symbol}}) precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol, Symbol}})
precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol}}) precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol}})

227
src/series.jl
View File

@ -108,10 +108,16 @@ compute_xyz(x::Nothing, y::Nothing, z::Nothing) = error("x/y/z are all no
# we are going to build recipes to do the processing and splitting of the args # 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 # ensure we dispatch to the slicer
struct SliceIt end struct SliceIt end
# the catch-all recipes # 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) @recipe function f(::Type{SliceIt}, x, y, z)
# handle data with formatting attached # handle data with formatting attached
@ -132,7 +138,6 @@ struct SliceIt end
ys = series_vector(y, plotattributes) ys = series_vector(y, plotattributes)
zs = series_vector(z, plotattributes) zs = series_vector(z, plotattributes)
fr = pop!(plotattributes, :fillrange, nothing) fr = pop!(plotattributes, :fillrange, nothing)
fillranges = process_fillrange(fr, plotattributes) fillranges = process_fillrange(fr, plotattributes)
mf = length(fillranges) mf = length(fillranges)
@ -141,8 +146,6 @@ struct SliceIt end
ribbons = process_ribbon(rib, plotattributes) ribbons = process_ribbon(rib, plotattributes)
mr = length(ribbons) mr = length(ribbons)
# @show zs
mx = length(xs) mx = length(xs)
my = length(ys) my = length(ys)
mz = length(zs) mz = length(zs)
@ -167,6 +170,11 @@ struct SliceIt end
nothing # don't add a series for the main block nothing # don't add a series for the main block
end end
# --------------------------------------------------------------------
# Apply type recipes
# --------------------------------------------------------------------
# this is the default "type recipe"... just pass the object through # 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
@ -207,24 +215,20 @@ function _apply_type_recipe(plotattributes, v::AbstractArray, letter)
return w return w
end end
# # special handling for Surface... need to properly unwrap and re-wrap # special handling for Surface... need to properly unwrap and re-wrap
# function _apply_type_recipe(plotattributes, v::Surface) _apply_type_recipe(plotattributes, v::Surface{<:AMat{<:DataPoint}}) = v
# T = eltype(v.surf) function _apply_type_recipe(plotattributes, v::Surface)
# @show T ret = _apply_type_recipe(plotattributes, v.surf)
# if T <: Integer || T <: AbstractFloat if typeof(ret) <: Formatted
# v Formatted(Surface(ret.data), ret.formatter)
# else else
# ret = _apply_type_recipe(plotattributes, v.surf) Surface(ret.data)
# if typeof(ret) <: Formatted end
# Formatted(Surface(ret.data), ret.formatter) end
# else
# v
# end
# end
# end
# don't do anything for ints or floats # don't do anything for datapoints or nothing
_apply_type_recipe(plotattributes, v::AbstractArray{<:DataPoint}, letter) = v _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 # axis args before type recipes should still be mapped to all axes
function _preprocess_axis_args!(plotattributes) function _preprocess_axis_args!(plotattributes)
@ -257,8 +261,14 @@ function _postprocess_axis_args!(plotattributes, letter)
end end
end end
# --------------------------------------------------------------------
# Fallback user recipes calling type recipes
# --------------------------------------------------------------------
# handle "type recipes" by converting inputs, and then either re-calling or slicing # handle "type recipes" by converting inputs, and then either re-calling or slicing
@recipe function f(x, y, z) @recipe function f(x, y, z)
wrap_surfaces!(plotattributes, x, y, z)
did_replace = false did_replace = false
newx = _apply_type_recipe(plotattributes, x, :x) newx = _apply_type_recipe(plotattributes, x, :x)
x === newx || (did_replace = true) x === newx || (did_replace = true)
@ -273,6 +283,7 @@ end
end end
end end
@recipe function f(x, y) @recipe function f(x, y)
wrap_surfaces!(plotattributes, x, y)
did_replace = false did_replace = false
newx = _apply_type_recipe(plotattributes, x, :x) newx = _apply_type_recipe(plotattributes, x, :x)
x === newx || (did_replace = true) x === newx || (did_replace = true)
@ -285,6 +296,7 @@ end
end end
end end
@recipe function f(y) @recipe function f(y)
wrap_surfaces!(plotattributes, y)
newy = _apply_type_recipe(plotattributes, y, :y) newy = _apply_type_recipe(plotattributes, y, :y)
if y !== newy if y !== newy
newy newy
@ -311,12 +323,14 @@ end
end end
# # --------------------------------------------------------------------
# # 1 argument
# # --------------------------------------------------------------------
# helper function to ensure relevant attributes are wrapped by Surface # helper function to ensure relevant attributes are wrapped by Surface
function wrap_surfaces(plotattributes::AKW) 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) if haskey(plotattributes, :fill_z)
v = plotattributes[:fill_z] v = plotattributes[:fill_z]
if !isa(v, Surface) if !isa(v, Surface)
@ -325,42 +339,57 @@ function wrap_surfaces(plotattributes::AKW)
end end
end 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 (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image, :plots_heatmap), get(plotattributes, :seriestype, :none)) 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 # return a surface if this is a 3d plot, otherwise let it be sliced up
@recipe function f(mat::AMat{T}) where T<:Union{Integer,AbstractFloat,Missing} @recipe function f(mat::AMat)
if all3D(plotattributes) if all3D(plotattributes)
n,m = axes(mat) n, m = axes(mat)
wrap_surfaces(plotattributes) m, n, Surface(mat)
SliceIt, m, n, Surface(mat)
else else
SliceIt, nothing, mat, nothing nothing, mat, nothing
end end
end end
# if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface # if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface
@recipe function f(fmt::Formatted{T}) where T<:AbstractMatrix @recipe function f(fmt::Formatted{<:AMat})
if all3D(plotattributes) if all3D(plotattributes)
mat = fmt.data mat = fmt.data
n,m = axes(mat) n, m = axes(mat)
wrap_surfaces(plotattributes) m, n, Formatted(Surface(mat), fmt.formatter)
SliceIt, m, n, Formatted(Surface(mat), fmt.formatter)
else else
SliceIt, nothing, fmt, nothing nothing, fmt, nothing
end end
end end
# assume this is a Volume, so construct one # assume this is a Volume, so construct one
@recipe function f(vol::AbstractArray{T,3}, args...) where T<:Union{Number,Missing} @recipe function f(vol::AbstractArray{<:MaybeNumber, 3}, args...)
seriestype := :volume seriestype := :volume
SliceIt, nothing, Volume(vol, args...), nothing SliceIt, nothing, Volume(vol, args...), nothing
end end
# # images - grays # images - grays
function clamp_greys!(mat::AMat{T}) where T<:Gray function clamp_greys!(mat::AMat{<:Gray})
for i in eachindex(mat) for i in eachindex(mat)
mat[i].val < 0 && (mat[i] = Gray(0)) mat[i].val < 0 && (mat[i] = Gray(0))
mat[i].val > 1 && (mat[i] = Gray(1)) mat[i].val > 1 && (mat[i] = Gray(1))
@ -368,7 +397,7 @@ function clamp_greys!(mat::AMat{T}) where T<:Gray
mat mat
end end
@recipe function f(mat::AMat{T}) where T<:Gray @recipe function f(mat::AMat{<:Gray})
n, m = axes(mat) n, m = axes(mat)
if is_seriestype_supported(:image) if is_seriestype_supported(:image)
seriestype := :image seriestype := :image
@ -383,8 +412,7 @@ end
end end
end end
# # images - colors # images - colors
@recipe function f(mat::AMat{T}) where T<:Colorant @recipe function f(mat::AMat{T}) where T<:Colorant
n, m = axes(mat) n, m = axes(mat)
@ -402,8 +430,7 @@ end
end end
end end
# # plotting arbitrary shapes/polygons
# # plotting arbitrary shapes/polygons
@recipe function f(shape::Shape) @recipe function f(shape::Shape)
seriestype --> :shape seriestype --> :shape
@ -463,14 +490,14 @@ function tryrange(F, vec)
end end
error("$F is not a Function, or is not defined at any of the values $vec") error("$F is not a Function, or is not defined at any of the values $vec")
end end
#
# # --------------------------------------------------------------------
# # 2 arguments # --------------------------------------------------------------------
# # -------------------------------------------------------------------- # 2 arguments
# # --------------------------------------------------------------------
#
# # if functions come first, just swap the order (not to be confused with parametric functions... # if functions come first, just swap the order (not to be confused with parametric
# # as there would be more than one function passed in) # 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) F2 = typeof(x)
@ -478,58 +505,25 @@ end
x, f x, f
end end
#
# # --------------------------------------------------------------------
# # 3 arguments
# # --------------------------------------------------------------------
#
#
# # 3d line or scatter
@recipe function f(x::AVec, y::AVec, z::AVec) # --------------------------------------------------------------------
# st = get(plotattributes, :seriestype, :none) # 3 arguments
# if st == :scatter # --------------------------------------------------------------------
# plotattributes[:seriestype] = :scatter3d
# elseif !is3d(st)
# plotattributes[:seriestype] = :path3d
# end
SliceIt, x, y, z
end
@recipe function f(x::AMat, y::AMat, z::AMat)
# st = get(plotattributes, :seriestype, :none)
# if size(x) == size(y) == size(z)
# if !is3d(st)
# seriestype := :path3d
# end
# end
wrap_surfaces(plotattributes)
SliceIt, x, y, z
end
#
# # surface-like... function
# surface-like... function
@recipe function f(x::AVec, y::AVec, zf::Function) @recipe function f(x::AVec, y::AVec, zf::Function)
# x = X <: Number ? sort(x) : x x, y, Surface(zf, x, y) # TODO: replace with SurfaceFunction when supported
# y = Y <: Number ? sort(y) : y
wrap_surfaces(plotattributes)
SliceIt, x, y, Surface(zf, x, y) # TODO: replace with SurfaceFunction when supported
end end
# # surface-like... matrix grid
# # surface-like... matrix grid
@recipe function f(x::AVec, y::AVec, z::AMat) @recipe function f(x::AVec, y::AVec, z::AMat)
if !like_surface(get(plotattributes, :seriestype, :none)) if !like_surface(get(plotattributes, :seriestype, :none))
plotattributes[:seriestype] = :contour plotattributes[:seriestype] = :contour
end end
wrap_surfaces(plotattributes) x, y, Surface(z)
SliceIt, x, y, Surface(z)
end end
# # images - grays # 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) if is_seriestype_supported(:image)
seriestype := :image seriestype := :image
@ -544,8 +538,7 @@ end
end end
end end
# # images - colors # 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) if is_seriestype_supported(:image)
seriestype := :image seriestype := :image
@ -560,14 +553,12 @@ end
end end
end end
#
#
# # --------------------------------------------------------------------
# # Parametric functions
# # --------------------------------------------------------------------
# # --------------------------------------------------------------------
# # special handling... xmin/xmax with parametric function(s) # Parametric functions
# --------------------------------------------------------------------
# special handling... xmin/xmax with parametric function(s)
@recipe function f(f::Function, xmin::Number, xmax::Number) @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=(:xscale,:yscale)]
_scaled_adapted_grid(f, xscale, yscale, xmin, xmax) _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
@ -585,8 +576,7 @@ function _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
xinv.(xs), yinv.(ys) xinv.(xs), yinv.(ys)
end end
# # special handling... 3D parametric function(s)
# # 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) mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u)
end end
@ -594,12 +584,10 @@ end
fx, fy, fz, range(umin, stop = umax, length = numPoints) fx, fy, fz, range(umin, stop = umax, length = numPoints)
end end
#
# # --------------------------------------------------------------------
# # -------------------------------------------------------------------- # Lists of tuples and GeometryTypes.Points
# # 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(v::AVec{<:GeometryTypes.Point}) = unzip(v)
@ -609,23 +597,10 @@ end
# Special case for 4-tuples in :ohlc series # 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)
#
# # --------------------------------------------------------------------
# # handle grouping
# # --------------------------------------------------------------------
# @recipe function f(groupby::GroupBy, args...) # --------------------------------------------------------------------
# for (i,glab) in enumerate(groupby.groupLabels) # handle grouping
# # create a new series, with the label of the group, and an idxfilter (to be applied in slice_and_dice) # --------------------------------------------------------------------
# # TODO: use @series instead
# @show i, glab, groupby.groupIds[i]
# di = copy(plotattributes)
# get!(di, :label, string(glab))
# get!(di, :idxfilter, groupby.groupIds[i])
# push!(series_list, RecipeData(di, args))
# end
# nothing
# end
splittable_kw(key, val, lengthGroup) = false 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