Merge pull request #2557 from JuliaPlots/ds/rewrite
Use RecipesPipeline
This commit is contained in:
Daniel Schwabeneder
GitHub
commit
70f207f5cc
@ -1,7 +1,7 @@
|
||||
name = "Plots"
|
||||
uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
|
||||
author = ["Tom Breloff (@tbreloff)"]
|
||||
version = "1.0.7"
|
||||
version = "1.0.8"
|
||||
|
||||
[deps]
|
||||
Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
|
||||
@ -22,6 +22,7 @@ Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
|
||||
REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
|
||||
Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
|
||||
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"
|
||||
@ -43,8 +44,9 @@ PGFPlotsX = "1.2.0"
|
||||
PlotThemes = "1"
|
||||
PlotUtils = "0.6.5"
|
||||
RecipesBase = "1"
|
||||
RecipesPipeline = "0.1.1"
|
||||
Reexport = "0.2"
|
||||
Requires = "0.5, 1.0"
|
||||
Requires = "0.5, 1"
|
||||
Showoff = "0.3.1"
|
||||
StatsBase = "0.32, 0.33"
|
||||
julia = "1"
|
||||
|
||||
21
src/Plots.jl
21
src/Plots.jl
@ -167,6 +167,26 @@ using .PlotMeasures
|
||||
import .PlotMeasures: Length, AbsoluteLength, Measure, width, height
|
||||
# ---------------------------------------------------------
|
||||
|
||||
import RecipesPipeline
|
||||
import RecipesPipeline: SliceIt,
|
||||
DefaultsDict,
|
||||
Formatted,
|
||||
AbstractSurface,
|
||||
Surface,
|
||||
Volume,
|
||||
is3d,
|
||||
is_surface,
|
||||
needs_3d_axes,
|
||||
group_as_matrix, # for StatsPlots
|
||||
reset_kw!,
|
||||
pop_kw!,
|
||||
scale_func,
|
||||
inverse_scale_func,
|
||||
unzip,
|
||||
dateformatter,
|
||||
datetimeformatter,
|
||||
timeformatter
|
||||
|
||||
include("types.jl")
|
||||
include("utils.jl")
|
||||
include("components.jl")
|
||||
@ -175,7 +195,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")
|
||||
|
||||
109
src/args.jl
109
src/args.jl
@ -86,13 +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) = seriestype in _surface_like
|
||||
like_surface(seriestype::Symbol) = RecipesPipeline.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"
|
||||
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])
|
||||
|
||||
@ -685,7 +682,7 @@ end
|
||||
|
||||
function default(; kw...)
|
||||
kw = KW(kw)
|
||||
preprocessArgs!(kw)
|
||||
RecipesPipeline.preprocess_attributes!(kw)
|
||||
for (k,v) in kw
|
||||
default(k, v)
|
||||
end
|
||||
@ -938,11 +935,11 @@ function _add_markershape(plotattributes::AKW)
|
||||
end
|
||||
|
||||
"Handle all preprocessing of args... break out colors/sizes/etc and replace aliases."
|
||||
function preprocessArgs!(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)
|
||||
@ -951,7 +948,7 @@ function preprocessArgs!(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)
|
||||
@ -969,7 +966,7 @@ function preprocessArgs!(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)
|
||||
@ -978,13 +975,13 @@ function preprocessArgs!(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)
|
||||
@ -993,14 +990,14 @@ function preprocessArgs!(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)
|
||||
@ -1010,7 +1007,7 @@ function preprocessArgs!(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
|
||||
@ -1031,14 +1028,14 @@ function preprocessArgs!(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
|
||||
|
||||
@ -1052,7 +1049,7 @@ function preprocessArgs!(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
|
||||
@ -1066,7 +1063,7 @@ function preprocessArgs!(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)
|
||||
@ -1115,75 +1112,13 @@ function preprocessArgs!(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 extractGroupArgs(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 extractGroupArgs(vs::Tuple, args...)
|
||||
isempty(vs) && return GroupBy([""], [axes(args[1],1)])
|
||||
v = map(tuple, vs...)
|
||||
extractGroupArgs(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...)
|
||||
isempty(vs) && return GroupBy([""], [axes(args[1],1)])
|
||||
v = map(NamedTuple{keys(vs)}∘tuple, values(vs)...)
|
||||
extractGroupArgs(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}}
|
||||
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
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
|
||||
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 +1142,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 +1154,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]
|
||||
@ -1277,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
|
||||
@ -1538,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)
|
||||
|
||||
62
src/axes.jl
62
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...)
|
||||
@ -85,7 +85,7 @@ function attr!(axis::Axis, args...; kw...)
|
||||
end
|
||||
|
||||
# then preprocess keyword arguments
|
||||
preprocessArgs!(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
|
||||
@ -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 = 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
|
||||
@ -161,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,
|
||||
@ -172,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
|
||||
@ -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(RecipesPipeline.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(RecipesPipeline.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 && !RecipesPipeline.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 = 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)
|
||||
@ -514,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
|
||||
@ -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 = 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)
|
||||
@ -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 = 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)
|
||||
@ -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 = 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)
|
||||
@ -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 = 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)
|
||||
@ -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 = 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)
|
||||
|
||||
@ -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]
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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)
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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]...)
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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
|
||||
@ -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}
|
||||
|
||||
361
src/pipeline.jl
361
src/pipeline.jl
@ -1,127 +1,74 @@
|
||||
# Error for aliases used in recipes
|
||||
function warn_on_recipe_aliases!(plotattributes, recipe_type, args...)
|
||||
# RecipesPipeline API
|
||||
|
||||
## Warnings
|
||||
|
||||
function RecipesPipeline.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)
|
||||
plotattributes[dk] = RecipesPipeline.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 RecipesPipeline.warn_on_recipe_aliases!(
|
||||
plt::Plot,
|
||||
v::AbstractVector,
|
||||
recipe_type,
|
||||
args...,
|
||||
)
|
||||
foreach(x -> RecipesPipeline.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 RecipesPipeline.warn_on_recipe_aliases!(
|
||||
plt::Plot,
|
||||
rd::RecipeData,
|
||||
recipe_type,
|
||||
args...,
|
||||
)
|
||||
RecipesPipeline.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
|
||||
|
||||
RecipesPipeline.splittable_attribute(plt::Plot, key, val::SeriesAnnotations, len) =
|
||||
RecipesPipeline.splittable_attribute(plt, key, val.strs, len)
|
||||
|
||||
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
|
||||
|
||||
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 = (extractGroupArgs(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
|
||||
RecipesPipeline.preprocess_attributes!(plt::Plot, plotattributes) =
|
||||
RecipesPipeline.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
|
||||
RecipesPipeline.is_axis_attribute(plt::Plot, attr) = is_axis_attr_noletter(attr) # in src/args.jl
|
||||
|
||||
args
|
||||
end
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# user recipes
|
||||
RecipesPipeline.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
|
||||
preprocessArgs!(kw)
|
||||
function RecipesPipeline.process_userrecipe!(plt::Plot, kw_list, kw)
|
||||
_preprocess_userrecipe(kw)
|
||||
warnOnUnsupported_scales(plt.backend, kw)
|
||||
|
||||
warn_on_unsupported_scales(plt.backend, kw)
|
||||
# add the plot index
|
||||
plt.n += 1
|
||||
kw[:series_plotindex] = plt.n
|
||||
@ -135,18 +82,17 @@ 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?
|
||||
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,59 +124,43 @@ 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
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# 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
|
||||
preprocessArgs!(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
|
||||
RecipesPipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], letter)
|
||||
|
||||
|
||||
## Plot recipes
|
||||
|
||||
RecipesPipeline.type_alias(plt::Plot) = get(_typeAliases, st, st)
|
||||
|
||||
|
||||
## Plot setup
|
||||
|
||||
function RecipesPipeline.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 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
|
||||
for kw in kw_list, (k, v) in kw
|
||||
haskey(_plot_defaults, k) && (plotattributes[k] = pop!(kw, k))
|
||||
end
|
||||
|
||||
@ -241,7 +171,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 +196,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 +212,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 +249,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
|
||||
@ -326,9 +262,34 @@ 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 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
|
||||
|
||||
RecipesPipeline.series_defaults(plt::Plot) = _series_defaults # in args.jl
|
||||
|
||||
RecipesPipeline.is_seriestype_supported(plt::Plot, st) = is_seriestype_supported(st)
|
||||
|
||||
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)
|
||||
_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
|
||||
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)
|
||||
@ -337,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 RecipesPipeline.needs_3d_axes(st)
|
||||
sp.attr[:projection] = "3d"
|
||||
end
|
||||
|
||||
@ -349,14 +310,12 @@ 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))
|
||||
if !RecipesPipeline.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 +323,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,56 +341,10 @@ 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)
|
||||
_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)
|
||||
#println("process $(typeof(plotattributes))")
|
||||
# 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)
|
||||
_prepare_annotations(sp, 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)
|
||||
preprocessArgs!(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
|
||||
|
||||
90
src/plot.jl
90
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)
|
||||
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)
|
||||
preprocessArgs!(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)
|
||||
preprocessArgs!(plotattributes)
|
||||
RecipesPipeline.preprocess_attributes!(plotattributes)
|
||||
# merge!(plt.user_attr, plotattributes)
|
||||
_plot!(plt, plotattributes, args)
|
||||
end
|
||||
@ -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)
|
||||
RecipesPipeline.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
|
||||
|
||||
|
||||
@ -288,5 +212,3 @@ function plot!(sp::Subplot, args...; kw...)
|
||||
plt = sp.plt
|
||||
plot!(plt, args...; kw..., subplot = findfirst(isequal(sp), plt.subplots))
|
||||
end
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
|
||||
@ -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(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})
|
||||
@ -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}})
|
||||
@ -53,15 +51,8 @@ function _precompile_()
|
||||
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}, 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})
|
||||
@ -98,75 +89,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}, 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.Attr, 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}}})
|
||||
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 +131,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 +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._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}, 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._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), 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._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), 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.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!), 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}})
|
||||
@ -330,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.Attr, 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.Attr, 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.Attr, 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})
|
||||
@ -344,29 +194,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}, 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.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}, 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.Attr, 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.Attr, 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.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), 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})
|
||||
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 +241,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), 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.Attr, 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.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 +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.Attr, 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}})
|
||||
@ -450,19 +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.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.Attr})
|
||||
precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr})
|
||||
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.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), RecipesPipeline.DefaultsDict})
|
||||
precompile(Tuple{typeof(Plots.font), Int64, Int})
|
||||
precompile(Tuple{typeof(Plots.font), String, Int})
|
||||
precompile(Tuple{typeof(Plots.font), Symbol, Int})
|
||||
@ -498,6 +328,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 +375,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}})
|
||||
@ -562,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}})
|
||||
@ -575,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})
|
||||
@ -587,12 +421,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 +442,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 +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.Attr})
|
||||
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}})
|
||||
@ -656,8 +490,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), 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}})
|
||||
@ -666,15 +500,14 @@ 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.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})
|
||||
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 +518,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 +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.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})
|
||||
@ -735,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.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}})
|
||||
@ -750,18 +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.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.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.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 +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.Attr, 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})
|
||||
@ -794,18 +619,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!), 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.Attr, 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}})
|
||||
@ -816,23 +634,15 @@ 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}, 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})
|
||||
@ -849,14 +659,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 +677,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 +685,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 +693,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, 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})
|
||||
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}}})
|
||||
|
||||
136
src/recipes.jl
136
src/recipes.jl
@ -457,6 +457,8 @@ end
|
||||
()
|
||||
end
|
||||
@deps plots_heatmap shape
|
||||
is_3d(::Type{Val{:plots_heatmap}}) = true
|
||||
RecipesPipeline.is_surface(::Type{Val{:plots_heatmap}}) = true
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Histograms
|
||||
@ -1162,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
|
||||
|
||||
@ -1178,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}) = 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] :
|
||||
RecipesPipeline.unzip(xyuv)
|
||||
|
||||
|
||||
# -------------------------------------------------
|
||||
|
||||
# TODO: move OHLC to PlotRecipes finance.jl
|
||||
@ -1301,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
|
||||
|
||||
|
||||
659
src/series.jl
659
src/series.jl
@ -1,659 +0,0 @@
|
||||
|
||||
|
||||
# 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}
|
||||
|
||||
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})
|
||||
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)
|
||||
|
||||
# default: assume x represents a single series
|
||||
series_vector(x, plotattributes) = [prepareSeriesData(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)]
|
||||
|
||||
# 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)
|
||||
[prepareSeriesData(Surface(v))]
|
||||
else
|
||||
[prepareSeriesData(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)
|
||||
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., 1.))
|
||||
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
|
||||
|
||||
# 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)
|
||||
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
|
||||
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
# 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=(: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)]
|
||||
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
|
||||
@ -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
|
||||
)
|
||||
|
||||
65
src/types.jl
65
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
|
||||
|
||||
19
src/utils.jl
19
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
|
||||
@ -143,19 +143,16 @@ 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}},
|
||||
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
|
||||
@ -190,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
|
||||
|
||||
@ -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 = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale)
|
||||
map(invf, _heatmap_edges(map(f,v), isedges))
|
||||
end
|
||||
|
||||
@ -838,7 +835,7 @@ end
|
||||
|
||||
function attr!(series::Series; kw...)
|
||||
plotattributes = KW(kw)
|
||||
preprocessArgs!(plotattributes)
|
||||
RecipesPipeline.preprocess_attributes!(plotattributes)
|
||||
for (k,v) in plotattributes
|
||||
if haskey(_series_defaults, k)
|
||||
series[k] = v
|
||||
@ -852,7 +849,7 @@ end
|
||||
|
||||
function attr!(sp::Subplot; kw...)
|
||||
plotattributes = KW(kw)
|
||||
preprocessArgs!(plotattributes)
|
||||
RecipesPipeline.preprocess_attributes!(plotattributes)
|
||||
for (k,v) in plotattributes
|
||||
if haskey(_subplot_defaults, k)
|
||||
sp[k] = v
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user