Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Simon Christ
|
250aef9b2d | ||
|
Simon Christ
|
d4d05d9e36 |
@@ -59,7 +59,7 @@ jobs:
|
||||
run: $TESTCMD --project -e 'include("deps/SnoopCompile/snoop_bench.jl")' # NOTE: optional, if have benchmark file
|
||||
|
||||
- name: Upload all
|
||||
uses: actions/upload-artifact@v2.0.1
|
||||
uses: actions/upload-artifact@v2
|
||||
with:
|
||||
path: ./
|
||||
|
||||
|
||||
+4
-4
@@ -1,7 +1,7 @@
|
||||
name = "Plots"
|
||||
uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
|
||||
author = ["Tom Breloff (@tbreloff)"]
|
||||
version = "1.6.4"
|
||||
version = "1.6.0"
|
||||
|
||||
[deps]
|
||||
Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
|
||||
@@ -35,8 +35,8 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
|
||||
Contour = "0.5"
|
||||
FFMPEG = "0.2, 0.3, 0.4"
|
||||
FixedPointNumbers = "0.6, 0.7, 0.8"
|
||||
GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52"
|
||||
GeometryBasics = "0.2, 0.3.1"
|
||||
GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51"
|
||||
GeometryBasics = "0.2"
|
||||
GeometryTypes = "0.7, 0.8"
|
||||
JSON = "0.21, 1"
|
||||
Measures = "0.3"
|
||||
@@ -45,7 +45,7 @@ PGFPlotsX = "1.2.0"
|
||||
PlotThemes = "2"
|
||||
PlotUtils = "1"
|
||||
RecipesBase = "1"
|
||||
RecipesPipeline = "0.1.13"
|
||||
RecipesPipeline = "0.1.12"
|
||||
Reexport = "0.2"
|
||||
Requires = "1"
|
||||
Showoff = "0.3.1"
|
||||
|
||||
+956
-345
File diff suppressed because it is too large
Load Diff
+1134
-588
File diff suppressed because it is too large
Load Diff
+1131
-607
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
+956
-341
File diff suppressed because it is too large
Load Diff
+1134
-581
File diff suppressed because it is too large
Load Diff
+1131
-582
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
+956
-346
File diff suppressed because it is too large
Load Diff
+559
-15
@@ -59,6 +59,7 @@ function _precompile_()
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:parent,),Tuple{Plots.Subplot{Plots.PlotlyBackend}}},Type{Plots.Subplot},Plots.PlotlyBackend})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots._make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Array{Int64,1}}},typeof(Plots._make_hist),Tuple{Array{Float64,1}},Symbol})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots._make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(Plots._make_hist),Tuple{Array{Float64,1},Array{Float64,1}},Int64})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots._make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(Plots._make_hist),Tuple{Array{Float64,1},Array{Float64,1}},Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots._make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(Plots._make_hist),Tuple{Array{Float64,1}},Symbol})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:flip,),Tuple{Bool}},typeof(attr!),Plots.Axis})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:formatter,),Tuple{Symbol}},typeof(attr!),Plots.Axis})
|
||||
@@ -78,43 +79,59 @@ function _precompile_()
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:ticks,),Tuple{UnitRange{Int64}}},typeof(attr!),Plots.Axis})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.contour)),NamedTuple{(:fill,),Tuple{Bool}},typeof(contour),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid),Tuple{Tuple{Int64,String},Int64,Tuple{Int64,Symbol},Tuple{Int64,Symbol},String,Symbol,Bool}},typeof(default)})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),Array{Int64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),StepRange{Int64,Int64},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),UnitRange{Int64},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),UnitRange{Int64},UnitRange{Int64}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_set_font)),NamedTuple{(:halign, :valign, :rotation),Tuple{Symbol,Symbol,Int64}},typeof(Plots.gr_set_font),Plots.Font,Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_set_font)),NamedTuple{(:halign, :valign, :rotation, :color),Tuple{Symbol,Symbol,Int64,RGBA{Float64}}},typeof(Plots.gr_set_font),Plots.Font,Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.heatmap)),NamedTuple{(:aspect_ratio,),Tuple{Int64}},typeof(heatmap),Array{String,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.histogram)),NamedTuple{(:bins, :weights),Tuple{Symbol,Array{Int64,1}}},typeof(histogram),Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.histogram2d)),NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio),Tuple{Tuple{Int64,Int64},Bool,Bool,Int64}},typeof(histogram2d),Array{Complex{Float64},1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.histogram2d)),NamedTuple{(:nbins,),Tuple{Int64}},typeof(histogram2d),Array{Float64,1},Vararg{Array{Float64,1},N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.hline!)),NamedTuple{(:line,),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}}}},typeof(hline!),Array{Float64,2}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.lens!)),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(lens!),Array{Int64,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.mesh3d)),NamedTuple{(:connections,),Tuple{Tuple{Array{Int64,1},Array{Int64,1},Array{Int64,1}}}},typeof(mesh3d),Array{Int64,1},Vararg{Array{Int64,1},N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.pie)),NamedTuple{(:title, :l),Tuple{String,Float64}},typeof(pie),Array{String,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Array{GeometryBasics.Point{2,Float64},1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Plots.Plot{Plots.GRBackend},Array{GeometryBasics.Point{2,Float64},1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend},Array{GeometryBasics.Point{2,Float64},1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,Plots.PlotText},1}}},typeof(plot!),Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,Plots.PlotText},1}}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,Plots.PlotText},1}}},typeof(plot!)})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Array{Float64,2}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Float64,2}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend},Array{Float64,2}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),Plots.Plot{Plots.GRBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:markersize, :c, :seriestype),Tuple{Int64,Symbol,Symbol}},typeof(plot!),Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:markersize, :c, :seriestype),Tuple{Int64,Symbol,Symbol}},typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:markersize, :c, :seriestype),Tuple{Int64,Symbol,Symbol}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,Measures.BoundingBox{Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}},Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}}}}}},typeof(plot!),Array{Int64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,Measures.BoundingBox{Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}},Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}}}}}},typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Int64,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,Measures.BoundingBox{Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}},Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}}}}}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend},Array{Int64,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Array{Int64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Int64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend},Array{Int64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:title,),Tuple{String}},typeof(plot!),Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:title,),Tuple{String}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:title,),Tuple{String}},typeof(plot!)})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot!),Array{Float64,1},Array{Float64,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Float64,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:xgrid,),Tuple{Tuple{Symbol,Symbol,Int64,Symbol,Float64}}},typeof(plot!),Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:xgrid,),Tuple{Tuple{Symbol,Symbol,Int64,Symbol,Float64}}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:yaxis,),Tuple{Tuple{String,Symbol}}},typeof(plot!),Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:yaxis,),Tuple{Tuple{String,Symbol}}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:yaxis,),Tuple{Tuple{String,Symbol}}},typeof(plot!)})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:annotations, :leg),Tuple{Tuple{Int64,Float64,Plots.PlotText},Bool}},typeof(plot),Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:arrow,),Tuple{Int64}},typeof(plot),Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:aspect_ratio, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{String,1},Array{String,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:color, :line, :marker),Tuple{Array{Symbol,2},Tuple{Symbol,Int64},Tuple{Array{Symbol,2},Int64,Float64,Plots.Stroke}}},typeof(plot),Array{Array{T,1} where T,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:connections, :seriestype),Tuple{Tuple{Array{Int64,1},Array{Int64,1},Array{Int64,1}},Symbol}},typeof(plot),Array{Int64,1},Array{Int64,1},Vararg{Array{Int64,1},N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:fill, :seriestype),Tuple{Bool,Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype),Tuple{Array{Symbol,2},Array{String,2},Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64,String,Int64,UnitRange{Int64},Symbol}},typeof(plot),Array{Array{Float64,1},1},Array{Array{Float64,1},1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:grid, :title),Tuple{Tuple{Symbol,Symbol,Symbol,Int64,Float64},String}},typeof(plot),Array{Float64,1}})
|
||||
@@ -129,7 +146,7 @@ function _precompile_()
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :palette, :bg_inside),Tuple{Int64,Array{PlotUtils.ContinuousColorGradient,2},Array{Symbol,2}}},typeof(plot),Array{Float64,2}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border),Tuple{Plots.GridLayout,Array{Symbol,2},Bool,Nothing,Symbol}},typeof(plot),Array{Float64,2}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation),Tuple{Plots.GridLayout,Array{String,2},Symbol,Array{Measures.Length{:mm,Float64},2},Measures.Length{:mm,Float64},Int64}},typeof(plot),Array{Float64,2}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :xlims),Tuple{Plots.GridLayout,Tuple{Int64,Float64}}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Vararg{Plots.Plot{Plots.GRBackend},N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout,),Tuple{Plots.GridLayout}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Vararg{Plots.Plot{Plots.GRBackend},N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:legend,),Tuple{Bool}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Vararg{Plots.Plot{Plots.GRBackend},N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:legend,),Tuple{Bool}},typeof(plot),Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend},Vararg{Plots.Plot{Plots.PlotlyBackend},N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Array{Tuple{Int64,Real},1}})
|
||||
@@ -141,7 +158,9 @@ function _precompile_()
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg),Tuple{Tuple{Int64,Symbol,Symbol},Tuple{Shape,Int64,RGBA{Float64}},Symbol,Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Bool}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:line_z, :linewidth, :legend),Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Int64,Bool}},typeof(plot),Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:m, :lab, :bg, :xlim, :ylim, :seriestype),Tuple{Tuple{Int64,Symbol},Array{String,2},Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:marker,),Tuple{Bool}},typeof(plot),Array{Complex{Float64},1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:marker,),Tuple{Bool}},typeof(plot),Array{Union{Missing, Int64},1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype),Tuple{typeof(+),Symbol,Bool,Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:nbins, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:proj, :m),Tuple{Symbol,Int64}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:reg, :fill),Tuple{Bool,Tuple{Int64,Symbol}}},typeof(plot),Array{Float64,1}})
|
||||
@@ -149,11 +168,12 @@ function _precompile_()
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:ribbon,),Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:ribbon,),Tuple{Tuple{LinRange{Float64},LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:ribbon,),Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color),Tuple{Array{Symbol,2},Array{Symbol,1},Int64,Array{Symbol,1}}},typeof(plot),Array{Float64,2}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot),Array{Dates.DateTime,1},UnitRange{Int64},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title, :l, :seriestype),Tuple{String,Float64,Symbol}},typeof(plot),Array{String,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title,),Tuple{Array{String,2}}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title,),Tuple{Array{String,2}}},typeof(plot),Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title,),Tuple{String}},typeof(plot),Array{Float64,1}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title,),Tuple{String}},typeof(plot),Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title,),Tuple{String}},typeof(plot),Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot),Array{Float64,2}})
|
||||
@@ -167,38 +187,149 @@ function _precompile_()
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.scatter)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks),Tuple{Array{Symbol,2},Array{String,2},Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64,String,Int64,UnitRange{Int64}}},typeof(scatter),Array{Array{Float64,1},1},Vararg{Array{Array{Float64,1},1},N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.scatter)),NamedTuple{(:m, :lab, :bg, :xlim, :ylim),Tuple{Tuple{Int64,Symbol},Array{String,2},Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64}}},typeof(scatter),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.scatter)),NamedTuple{(:marker_z, :color, :legend),Tuple{typeof(+),Symbol,Bool}},typeof(scatter),Array{Float64,1},Vararg{Array{Float64,1},N} where N})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.test_examples)),NamedTuple{(:skip, :disp),Tuple{Array{Int64,1},Bool}},typeof(test_examples),Symbol})
|
||||
Base.precompile(Tuple{Core.kwftype(typeof(Plots.test_examples)),NamedTuple{(:skip,),Tuple{Array{Int64,1}}},typeof(test_examples),Symbol})
|
||||
Base.precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Axes,F,Args} where Args<:Tuple where F where Axes},typeof(Plots.contour_levels),Tuple{Array{Any,1},Base.RefValue{Tuple{Float64,Float64}}}})
|
||||
Base.precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Axes,F,Args} where Args<:Tuple where F where Axes},typeof(Plots.get_colorgradient),Tuple{Array{Any,1}}})
|
||||
Base.precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Axes,F,Args} where Args<:Tuple where F where Axes},typeof(Plots.get_fillalpha),Tuple{Array{Any,1}}})
|
||||
Base.precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Axes,F,Args} where Args<:Tuple where F where Axes},typeof(Plots.get_linealpha),Tuple{Array{Any,1}}})
|
||||
Base.precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Axes,F,Args} where Args<:Tuple where F where Axes},typeof(Plots.get_linecolor),Tuple{Array{Any,1},Base.RefValue{Tuple{Float64,Float64}}}})
|
||||
Base.precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Axes,F,Args} where Args<:Tuple where F where Axes},typeof(Plots.get_linestyle),Tuple{Array{Any,1}}})
|
||||
Base.precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Axes,F,Args} where Args<:Tuple where F where Axes},typeof(Plots.get_linewidth),Tuple{Array{Any,1}}})
|
||||
Base.precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Axes,F,Args} where Args<:Tuple where F where Axes},typeof(Plots.get_z_normalized),Tuple{Array{Float64,1},Float64,Float64}})
|
||||
Base.precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Axes,F,Args} where Args<:Tuple where F where Axes},typeof(Plots.gr_color),Tuple{Array{RGBA{Float64},1}}})
|
||||
Base.precompile(Tuple{Type{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Axes,F,Args} where Args<:Tuple where F where Axes},typeof(Plots.gr_tick_label),Tuple{Tuple{Plots.Axis},Array{String,1}}})
|
||||
Base.precompile(Tuple{Type{Base.Generator},typeof(Plots.bottompad),Array{AbstractLayout,1}})
|
||||
Base.precompile(Tuple{Type{Base.Generator},typeof(Plots.leftpad),Array{AbstractLayout,1}})
|
||||
Base.precompile(Tuple{Type{Base.Generator},typeof(Plots.rightpad),Array{AbstractLayout,1}})
|
||||
Base.precompile(Tuple{Type{Base.Generator},typeof(Plots.toppad),Array{AbstractLayout,1}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:annotations, :leg),T} where T<:Tuple},Tuple{Tuple{Int64,Float64,Plots.PlotText},Bool}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:color, :line, :marker),T} where T<:Tuple},Tuple{Array{Symbol,2},Tuple{Symbol,Int64},Tuple{Array{Symbol,2},Int64,Float64,Plots.Stroke}}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:layout, :group, :linetype, :linecolor),T} where T<:Tuple},Tuple{Plots.GridLayout,Array{String,1},Array{Symbol,2},Symbol}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:layout, :t, :leg, :ticks, :border),T} where T<:Tuple},Tuple{Plots.GridLayout,Array{Symbol,2},Bool,Nothing,Symbol}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation),T} where T<:Tuple},Tuple{Plots.GridLayout,Array{String,2},Symbol,Array{Measures.Length{:mm,Float64},2},Measures.Length{:mm,Float64},Int64}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:layout,),T} where T<:Tuple},Tuple{Plots.GridLayout}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg),T} where T<:Tuple},Tuple{Tuple{Int64,Symbol,Symbol},Tuple{Shape,Int64,RGBA{Float64}},Symbol,Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Bool}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:parent,),T} where T<:Tuple},Tuple{Plots.Subplot{Plots.GRBackend}}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:parent,),T} where T<:Tuple},Tuple{Plots.Subplot{Plots.PlotlyBackend}}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:zcolor, :m, :leg, :cbar, :w),T} where T<:Tuple},Tuple{StepRange{Int64,Int64},Tuple{Int64,Float64,Symbol,Plots.Stroke},Bool,Bool,Int64}})
|
||||
Base.precompile(Tuple{Type{NamedTuple{(:zcolor, :m, :ms, :lab),T} where T<:Tuple},Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String}})
|
||||
Base.precompile(Tuple{Type{Pair},Symbol,Plots.Arrow})
|
||||
Base.precompile(Tuple{Type{Pair},Symbol,Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{Type{Pair},Symbol,Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{Type{Pair},Symbol,Plots.SeriesAnnotations})
|
||||
Base.precompile(Tuple{Type{Pair},Symbol,Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{Type{Pair},Symbol,Plots.Subplot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{Type{Pair},Symbol,Shape})
|
||||
Base.precompile(Tuple{Type{Plots.Font},String,Int64,Symbol,Symbol,Float64,RGBA{Float64}})
|
||||
Base.precompile(Tuple{Type{Plots.GridLayout},Int64,Vararg{Int64,N} where N})
|
||||
Base.precompile(Tuple{Type{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{Type{Plots.Plot},Plots.GRBackend,Int64,RecipesPipeline.DefaultsDict,Array{Plots.Series,1},Nothing,Array{Plots.Subplot,1},Dict{Any,Plots.Subplot},Plots.EmptyLayout,Array{Plots.Subplot,1},Bool})
|
||||
Base.precompile(Tuple{Type{Plots.Plot},Plots.PlotlyBackend,Int64,RecipesPipeline.DefaultsDict,Array{Plots.Series,1},Nothing,Array{Plots.Subplot,1},Dict{Any,Plots.Subplot},Plots.EmptyLayout,Array{Plots.Subplot,1},Bool})
|
||||
Base.precompile(Tuple{Type{Plots.SegmentsIterator},Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}},Int64,Int64})
|
||||
Base.precompile(Tuple{Type{Plots.SegmentsIterator},Tuple{Array{Float64,1},Array{Float64,1},UnitRange{Int64}},Int64,Int64})
|
||||
Base.precompile(Tuple{Type{Shape},Array{Tuple{Float64,Float64},1}})
|
||||
Base.precompile(Tuple{typeof(!=),Plots.Arrow,Nothing})
|
||||
Base.precompile(Tuple{typeof(!=),Shape,Symbol})
|
||||
Base.precompile(Tuple{typeof(*),Measures.Length{:mm,Float64},Measures.Length{:pct,Float64}})
|
||||
Base.precompile(Tuple{typeof(==),Array{Tuple{Int64,Float64,Plots.PlotText},1},Symbol})
|
||||
Base.precompile(Tuple{typeof(==),Plots.Arrow,Bool})
|
||||
Base.precompile(Tuple{typeof(==),Plots.Axis,Symbol})
|
||||
Base.precompile(Tuple{typeof(==),Plots.Extrema,Symbol})
|
||||
Base.precompile(Tuple{typeof(==),Tuple{Int64,Float64,Plots.PlotText},Symbol})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.broadcasted),Function,Tuple{Plots.Axis},Array{String,1}})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!),Array{Int64,1},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linewidth),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}}}},Base.OneTo{Int64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!),Array{Nothing,1},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_fillalpha),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}}}},Base.OneTo{Int64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!),Array{Nothing,1},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linealpha),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}}}},Base.OneTo{Int64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!),Array{PlotUtils.ContinuousColorGradient,1},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_colorgradient),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}}}},Base.OneTo{Int64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!),Array{PlotUtils.ContinuousColorGradient,1},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linecolor),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}},Base.RefValue{Tuple{Float64,Float64}}}},Base.OneTo{Int64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!),Array{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},1},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.contour_levels),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}},Base.RefValue{Tuple{Float64,Float64}}}},Base.OneTo{Int64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!),Array{Symbol,1},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linestyle),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}}}},Base.OneTo{Int64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.instantiate),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.get_colorgradient),Tuple{Array{Any,1}}}})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.instantiate),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.get_fillalpha),Tuple{Array{Any,1}}}})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.instantiate),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.get_linealpha),Tuple{Array{Any,1}}}})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.instantiate),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.get_linestyle),Tuple{Array{Any,1}}}})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.instantiate),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.get_linewidth),Tuple{Array{Any,1}}}})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.instantiate),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.gr_color),Tuple{Array{RGBA{Float64},1}}}})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.instantiate),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.gr_tick_label),Tuple{Tuple{Plots.Axis},Array{String,1}}}})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.materialize),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.contour_levels),Tuple{Array{Any,1},Base.RefValue{Tuple{Float64,Float64}}}}})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.materialize),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.get_linecolor),Tuple{Array{Any,1},Base.RefValue{Tuple{Float64,Float64}}}}})
|
||||
Base.precompile(Tuple{typeof(Base.Broadcast.materialize),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.get_z_normalized),Tuple{Array{Float64,1},Float64,Float64}}})
|
||||
Base.precompile(Tuple{typeof(Base._array_for),Type{Plots.Axis},Array{Any,1},Base.HasShape{1}})
|
||||
Base.precompile(Tuple{typeof(Base._compute_eltype),Type{Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String,Symbol}}})
|
||||
Base.precompile(Tuple{typeof(Base._compute_eltype),Type{Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String}}})
|
||||
Base.precompile(Tuple{typeof(Base._compute_eltype),Type{Tuple{Array{Symbol,2},Tuple{Symbol,Int64},Tuple{Array{Symbol,2},Int64,Float64,Plots.Stroke}}}})
|
||||
Base.precompile(Tuple{typeof(Base._compute_eltype),Type{Tuple{Plots.GridLayout,Array{String,1},Array{Symbol,2},Symbol}}})
|
||||
Base.precompile(Tuple{typeof(Base._compute_eltype),Type{Tuple{Plots.GridLayout,Array{String,2},Symbol,Array{Measures.Length{:mm,Float64},2},Measures.Length{:mm,Float64},Int64}}})
|
||||
Base.precompile(Tuple{typeof(Base._compute_eltype),Type{Tuple{Plots.GridLayout,Array{Symbol,2},Bool,Nothing,Symbol}}})
|
||||
Base.precompile(Tuple{typeof(Base._compute_eltype),Type{Tuple{StepRange{Int64,Int64},Tuple{Int64,Float64,Symbol,Plots.Stroke},Bool,Bool,Int64}}})
|
||||
Base.precompile(Tuple{typeof(Base._compute_eltype),Type{Tuple{Tuple{Int64,Float64,Plots.PlotText},Bool}}})
|
||||
Base.precompile(Tuple{typeof(Base._compute_eltype),Type{Tuple{Tuple{Int64,Symbol,Symbol},Tuple{Shape,Int64,RGBA{Float64}},Symbol,Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Bool}}})
|
||||
Base.precompile(Tuple{typeof(Base._similar_for),Array{Any,1},Type{Int64},Base.Generator{Array{Any,1},typeof(Plots.rowsize)},Base.HasShape{1}})
|
||||
Base.precompile(Tuple{typeof(Base.collect_similar),Array{AbstractLayout,1},Base.Generator{Array{AbstractLayout,1},typeof(Plots.bottompad)}})
|
||||
Base.precompile(Tuple{typeof(Base.collect_similar),Array{AbstractLayout,1},Base.Generator{Array{AbstractLayout,1},typeof(Plots.leftpad)}})
|
||||
Base.precompile(Tuple{typeof(Base.collect_similar),Array{AbstractLayout,1},Base.Generator{Array{AbstractLayout,1},typeof(Plots.rightpad)}})
|
||||
Base.precompile(Tuple{typeof(Base.collect_similar),Array{AbstractLayout,1},Base.Generator{Array{AbstractLayout,1},typeof(Plots.toppad)}})
|
||||
Base.precompile(Tuple{typeof(Base.collect_to_with_first!),Array{Int64,1},Int64,Base.Generator{Array{Any,1},typeof(Plots.rowsize)},Int64})
|
||||
Base.precompile(Tuple{typeof(Base.deepcopy_internal),Array{Plots.Series,1},IdDict{Any,Any}})
|
||||
Base.precompile(Tuple{typeof(Base.indexed_iterate),Tuple{Plots.GridLayout,Int64},Int64})
|
||||
Base.precompile(Tuple{typeof(Base.merge_types),NTuple{5,Symbol},Type{NamedTuple{(:zcolor, :m, :ms, :lab),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String}}},Type{NamedTuple{(:seriestype,),Tuple{Symbol}}}})
|
||||
Base.precompile(Tuple{typeof(Base.merge_types),Tuple{Symbol},Type{NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,Plots.PlotText},1}}}},Type{NamedTuple{(),Tuple{}}}})
|
||||
Base.precompile(Tuple{typeof(Base.promote_typeof),String,Plots.PlotText})
|
||||
Base.precompile(Tuple{typeof(Base.vect),Tuple{Int64,Float64,Plots.PlotText},Vararg{Tuple{Int64,Float64,Plots.PlotText},N} where N})
|
||||
Base.precompile(Tuple{typeof(Plots._backend_instance),Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots._cbar_unique),Array{Int64,1},String})
|
||||
Base.precompile(Tuple{typeof(Plots._cbar_unique),Array{Nothing,1},String})
|
||||
Base.precompile(Tuple{typeof(Plots._cbar_unique),Array{PlotUtils.ContinuousColorGradient,1},String})
|
||||
Base.precompile(Tuple{typeof(Plots._cbar_unique),Array{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},1},String})
|
||||
Base.precompile(Tuple{typeof(Plots._cbar_unique),Array{Symbol,1},String})
|
||||
Base.precompile(Tuple{typeof(Plots._create_backend_figure),Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots._create_backend_figure),Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Array{Any,1},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Array{Float64,1},Array{Int64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Array{Float64,1},StepRange{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Array{Float64,1},UnitRange{Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Array{Plots.Subplot,1},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Array{String,1},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Base.OneTo{Int64},Array{Int64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),ColorPalette,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Float64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Int64,StepRange{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Nothing,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Plots.Subplot{Plots.GRBackend},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Plots.Subplot{Plots.PlotlyBackend},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Shape,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),StepRange{Int64,Int64},Array{Int64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots._cycle),Symbol,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._heatmap_edges),Array{Float64,1},Bool})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{AbstractArray{Float64,1},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Array{Float64,1},1},Array{Array{Float64,1},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Array{T,1} where T,1},Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Array{T,1} where T,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Complex{Float64},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Dates.DateTime,1},UnitRange{Int64},Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Float64,1},Array{Float64,1},UnitRange{Int64}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Float64,1},Array{Float64,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Function,1},Array{Float64,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Function,1},Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Function,1},Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Int64,1},Array{Float64,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{OHLC,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{String,1},Array{Float64,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{String,1},Array{String,1},Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Tuple{Int64,Int64},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Tuple{Int64,Real},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Array{Union{Missing, Int64},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Plots.PortfolioComposition}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{Plots.Spy}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{StepRange{Int64,Int64},Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{UnitRange{Int64}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Tuple{typeof(log),Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{AbstractArray{Float64,1},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{Array{Float64,1},1},Array{Array{Float64,1},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{Array{T,1} where T,1},Array{Float64,2}}})
|
||||
@@ -209,10 +340,10 @@ function _precompile_()
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{Function,1},Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{Int64,1},Array{Float64,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{Int64,1},Array{Int64,1},Array{Int64,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{OHLC,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{String,1},Array{Float64,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{String,1},Array{String,1},Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{Tuple{Int64,Int64},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{Tuple{Int64,Real},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Array{Union{Missing, Int64},1}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{Plots.PortfolioComposition}})
|
||||
@@ -222,83 +353,292 @@ function _precompile_()
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{StepRange{Int64,Int64},Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Tuple{UnitRange{Int64}}})
|
||||
Base.precompile(Tuple{typeof(Plots._replace_markershape),Array{Symbol,1}})
|
||||
Base.precompile(Tuple{typeof(Plots._replace_markershape),Array{Symbol,2}})
|
||||
Base.precompile(Tuple{typeof(Plots._replace_markershape),Shape})
|
||||
Base.precompile(Tuple{typeof(Plots._slice_series_args!),Dict{Symbol,Any},Plots.Plot{Plots.GRBackend},Plots.Subplot{Plots.GRBackend},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._slice_series_args!),Dict{Symbol,Any},Plots.Plot{Plots.PlotlyBackend},Plots.Subplot{Plots.PlotlyBackend},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._slice_series_args!),RecipesPipeline.DefaultsDict,Plots.Plot{Plots.GRBackend},Plots.Subplot{Plots.GRBackend},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._slice_series_args!),RecipesPipeline.DefaultsDict,Plots.Plot{Plots.PlotlyBackend},Plots.Subplot{Plots.PlotlyBackend},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._transform_ticks),Nothing})
|
||||
Base.precompile(Tuple{typeof(Plots._transform_ticks),StepRange{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots._transform_ticks),Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots._transform_ticks),UnitRange{Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots._update_clims),Float64,Float64,Float64,Float64})
|
||||
Base.precompile(Tuple{typeof(Plots._update_clims),Float64,Float64,Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots._update_min_padding!),Plots.GridLayout})
|
||||
Base.precompile(Tuple{typeof(Plots._update_plot_args),Plots.Plot{Plots.GRBackend},RecipesPipeline.DefaultsDict})
|
||||
Base.precompile(Tuple{typeof(Plots._update_plot_args),Plots.Plot{Plots.PlotlyBackend},RecipesPipeline.DefaultsDict})
|
||||
Base.precompile(Tuple{typeof(Plots._update_subplot_args),Plots.Plot{Plots.GRBackend},Plots.Subplot{Plots.GRBackend},Dict{Symbol,Any},Int64,Bool})
|
||||
Base.precompile(Tuple{typeof(Plots._update_subplot_args),Plots.Plot{Plots.PlotlyBackend},Plots.Subplot{Plots.PlotlyBackend},Dict{Symbol,Any},Int64,Bool})
|
||||
Base.precompile(Tuple{typeof(Plots._update_subplot_periphery),Plots.Subplot{Plots.GRBackend},Array{Any,1}})
|
||||
Base.precompile(Tuple{typeof(Plots._update_subplot_periphery),Plots.Subplot{Plots.PlotlyBackend},Array{Any,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.allStyles),Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.attr),Plots.EmptyLayout,Symbol,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.attr),Plots.EmptyLayout,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.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}}}})
|
||||
Base.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}}}})
|
||||
Base.precompile(Tuple{typeof(Plots.bottompad),Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots.build_layout),Plots.GridLayout,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.calc_num_subplots),Plots.EmptyLayout})
|
||||
Base.precompile(Tuple{typeof(Plots.convertLegendValue),Bool})
|
||||
Base.precompile(Tuple{typeof(Plots.convertLegendValue),Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.convert_to_polar),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Int64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.create_grid),Expr})
|
||||
Base.precompile(Tuple{typeof(Plots.discrete_value!),Plots.Axis,Array{String,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.discrete_value!),Plots.Axis,Array{Union{Missing, Float64},1}})
|
||||
Base.precompile(Tuple{typeof(Plots.error_coords),Array{Float64,1},Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},N} where N})
|
||||
Base.precompile(Tuple{typeof(Plots.error_coords),Array{Float64,1},Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.error_zipit),Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.expand_extrema!),Plots.Axis,Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.expand_extrema!),Plots.Axis,Array{Int64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.expand_extrema!),Plots.Axis,Base.OneTo{Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.expand_extrema!),Plots.Axis,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
|
||||
Base.precompile(Tuple{typeof(Plots.expand_extrema!),Plots.Axis,StepRange{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.expand_extrema!),Plots.Axis,Surface{Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots.expand_extrema!),Plots.Axis,Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.expand_extrema!),Plots.Axis,Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.expand_extrema!),Plots.Axis,UnitRange{Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.extend_by_data!),Array{Float64,1},Float64})
|
||||
Base.precompile(Tuple{typeof(Plots.fakedata),Int64,Vararg{Int64,N} where N})
|
||||
Base.precompile(Tuple{typeof(Plots.get_clims),Plots.Subplot{Plots.GRBackend},Plots.Series,Function})
|
||||
Base.precompile(Tuple{typeof(Plots.get_fillcolor),Plots.Series,Tuple{Float64,Float64},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.get_fillcolor),Plots.Series,Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.get_gradient),PlotUtils.ContinuousColorGradient})
|
||||
Base.precompile(Tuple{typeof(Plots.get_linecolor),Plots.Series,Tuple{Float64,Float64},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.get_linecolor),Plots.Series,Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.get_minor_ticks),Plots.Subplot{Plots.GRBackend},Plots.Axis,Tuple{Array{Float64,1},Array{Any,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots.get_minor_ticks),Plots.Subplot{Plots.GRBackend},Plots.Axis,Tuple{Array{Float64,1},Array{String,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots.get_minor_ticks),Plots.Subplot{Plots.GRBackend},Plots.Axis,Tuple{Array{Int64,1},Array{String,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),Array{Symbol,1},Plots.Subplot{Plots.GRBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),Array{Symbol,1},Plots.Subplot{Plots.PlotlyBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),ColorPalette,Plots.Subplot{Plots.PlotlyBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),Int64,Plots.Subplot{Plots.GRBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),Int64,Plots.Subplot{Plots.PlotlyBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),PlotUtils.ContinuousColorGradient,Plots.Subplot{Plots.GRBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),PlotUtils.ContinuousColorGradient,Plots.Subplot{Plots.PlotlyBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),RGBA{Float64},Plots.Subplot{Plots.GRBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),RGBA{Float64},Plots.Subplot{Plots.PlotlyBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),Symbol,Plots.Subplot{Plots.GRBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_series_color),Symbol,Plots.Subplot{Plots.PlotlyBackend},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.get_subplot),Plots.Plot{Plots.GRBackend},Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots.get_subplot),Plots.Plot{Plots.PlotlyBackend},Plots.Subplot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots.get_thickness_scaling),Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots.get_xy),OHLC{Float64},Int64,Float64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_axis_height),Plots.Subplot{Plots.GRBackend},Plots.Axis})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_axis_width),Plots.Subplot{Plots.GRBackend},Plots.Axis})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_display),Plots.Subplot{Plots.GRBackend},Measures.Length{:mm,Float64},Measures.Length{:mm,Float64},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_colorbar),Plots.GRColorbar,Plots.Subplot{Plots.GRBackend},Tuple{Float64,Float64},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_marker),Plots.Series,Float64,Float64,Tuple{Float64,Float64},Int64,Float64,Float64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_marker),Plots.Series,Float64,Float64,Tuple{Float64,Float64},Int64,Int64,Int64,Shape})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_marker),Plots.Series,Float64,Float64,Tuple{Float64,Float64},Int64,Int64,Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_marker),Plots.Series,Int64,Float64,Tuple{Float64,Float64},Int64,Float64,Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_marker),Plots.Series,Int64,Float64,Tuple{Float64,Float64},Int64,Int64,Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_marker),Plots.Series,Int64,Int64,Tuple{Float64,Float64},Int64,Int64,Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Array{Float64,1},Array{Float64,1},Tuple{Float64,Float64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Array{Float64,1},Array{Float64,1},Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Array{Int64,1},Array{Float64,1},Tuple{Float64,Float64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Array{Int64,1},Array{Float64,1},Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Array{Int64,1},Array{Int64,1},Tuple{Float64,Float64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Array{Int64,1},Array{Int64,1},Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Base.OneTo{Int64},Array{Float64,1},Tuple{Float64,Float64},Array{Float64,1},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Base.OneTo{Int64},Array{Float64,1},Tuple{Float64,Float64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Base.OneTo{Int64},Array{Float64,1},Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Float64,Float64,Tuple{Float64,Float64},Float64,Float64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Float64,Float64},Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_fill_viewport),Array{Float64,1},RGBA{Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_get_ticks_size),Tuple{Array{Float64,1},Array{Any,1}},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_get_ticks_size),Tuple{Array{Float64,1},Array{String,1}},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_get_ticks_size),Tuple{Array{Int64,1},Array{String,1}},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_legend_pos),Plots.Subplot{Plots.GRBackend},Array{Float64,1},Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_legend_pos),Plots.Subplot{Plots.GRBackend},Float64,Float64,Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_polaraxes),Int64,Float64,Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_polyline),Array{Float64,1},Array{Float64,1},Function})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_text),Float64,Float64,String})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_set_bordercolor),RGBA{Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_set_fill),RGBA{Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_set_gradient),PlotUtils.ContinuousColorGradient})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_set_line),Float64,Symbol,RGBA{Float64},Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_set_line),Int64,Symbol,RGBA{Float64},Plots.Series})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_set_markercolor),RGBA{Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_set_textcolor),RGBA{Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_set_transparency),RGBA{Float64},Float64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_set_transparency),RGBA{Float64},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_set_transparency),RGBA{Float64},Nothing})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_text_size),String})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_tick_label),Plots.Axis,String})
|
||||
Base.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}})
|
||||
Base.precompile(Tuple{typeof(Plots.gr_w3tondc),Float64,Float64,Float64})
|
||||
Base.precompile(Tuple{typeof(Plots.heatmap_edges),Array{Float64,1},Symbol,Array{Float64,1},Symbol,Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.heatmap_edges),Array{Float64,1},Symbol,UnitRange{Int64},Symbol,Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.heatmap_edges),Array{Float64,1},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.heatmap_edges),Base.OneTo{Int64},Symbol,Base.OneTo{Int64},Symbol,Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.heatmap_edges),Base.OneTo{Int64},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.heatmap_edges),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Symbol,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Symbol,Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.heatmap_edges),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.heatmap_edges),UnitRange{Int64},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.ignorenan_extrema),Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.ignorenan_extrema),Array{Float64,2}})
|
||||
Base.precompile(Tuple{typeof(Plots.ignorenan_extrema),Base.OneTo{Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.ignorenan_extrema),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
|
||||
Base.precompile(Tuple{typeof(Plots.ignorenan_extrema),StepRange{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.ignorenan_maximum),Base.OneTo{Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.ignorenan_minimum),Array{Int64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.ignorenan_minimum),Base.OneTo{Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.intersection_point),Float64,Float64,Float64,Float64,Float64,Float64})
|
||||
Base.precompile(Tuple{typeof(Plots.is_2tuple),Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.is_2tuple),Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.is_2tuple),Tuple{Array{Float64,1},Array{Float64,1}}})
|
||||
Base.precompile(Tuple{typeof(Plots.is_2tuple),Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.is_2tuple),Tuple{Int64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.is_2tuple),Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.is_2tuple),Tuple{Int64,Measures.BoundingBox{Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}},Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}}}}})
|
||||
Base.precompile(Tuple{typeof(Plots.is_marker_supported),Plots.Stroke})
|
||||
Base.precompile(Tuple{typeof(Plots.is_marker_supported),Shape})
|
||||
Base.precompile(Tuple{typeof(Plots.is_uniformly_spaced),Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.ispolar),Plots.Subplot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots.labelfunc),Symbol,Plots.GRBackend})
|
||||
Base.precompile(Tuple{typeof(Plots.layout_args),Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.layout_args),Int64,Plots.GridLayout})
|
||||
Base.precompile(Tuple{typeof(Plots.layout_args),Int64,Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.layout_args),Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.layout_args),Plots.GridLayout})
|
||||
Base.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}}}})
|
||||
Base.precompile(Tuple{typeof(Plots.leftpad),Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots.link_axes!),Plots.Axis})
|
||||
Base.precompile(Tuple{typeof(Plots.link_axes!),Plots.Subplot{Plots.GRBackend},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.link_axes!),Plots.Subplot{Plots.PlotlyBackend},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.locate_annotation),Plots.Subplot{Plots.GRBackend},Int64,Float64,Plots.PlotText})
|
||||
Base.precompile(Tuple{typeof(Plots.make_fillrange_side),UnitRange{Int64},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.make_fillrange_side),UnitRange{Int64},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.make_fillrange_side),UnitRange{Int64},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
|
||||
Base.precompile(Tuple{typeof(Plots.make_steps),Nothing,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.optimal_ticks_and_labels),Plots.Subplot{Plots.GRBackend},Plots.Axis,StepRange{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.optimal_ticks_and_labels),Plots.Subplot{Plots.GRBackend},Plots.Axis,UnitRange{Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.plotarea!),Plots.GridLayout,Measures.BoundingBox{Tuple{Measures.Length{:mm,Float64},Measures.Length{:mm,Float64}},Tuple{Measures.Length{:mm,Float64},Measures.Length{:mm,Float64}}}})
|
||||
Base.precompile(Tuple{typeof(Plots.plotarea!),Plots.Subplot{Plots.GRBackend},Measures.BoundingBox{Tuple{Measures.Length{:mm,Float64},Measures.Length{:mm,Float64}},Tuple{Measures.Length{:mm,Float64},Measures.Length{:mm,Float64}}}})
|
||||
Base.precompile(Tuple{typeof(Plots.processFillArg),Dict{Symbol,Any},Bool})
|
||||
Base.precompile(Tuple{typeof(Plots.processFillArg),Dict{Symbol,Any},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.processFillArg),Dict{Symbol,Any},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.processFontArg!),Dict{Symbol,Any},Symbol,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.processFontArg!),Dict{Symbol,Any},Symbol,String})
|
||||
Base.precompile(Tuple{typeof(Plots.processFontArg!),Dict{Symbol,Any},Symbol,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.processGridArg!),Dict{Symbol,Any},Bool,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.processGridArg!),Dict{Symbol,Any},Float64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.processGridArg!),Dict{Symbol,Any},Int64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.processGridArg!),Dict{Symbol,Any},Symbol,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.processGridArg!),RecipesPipeline.DefaultsDict,Bool,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.processLineArg),Dict{Symbol,Any},Array{Symbol,2}})
|
||||
Base.precompile(Tuple{typeof(Plots.processLineArg),Dict{Symbol,Any},Float64})
|
||||
Base.precompile(Tuple{typeof(Plots.processLineArg),Dict{Symbol,Any},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.processLineArg),Dict{Symbol,Any},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Array{Symbol,2}})
|
||||
Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Bool})
|
||||
Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Float64})
|
||||
Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Plots.Stroke})
|
||||
Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},RGBA{Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Shape})
|
||||
Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.processMinorGridArg!),Dict{Symbol,Any},Bool,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.process_annotation),Plots.Subplot{Plots.GRBackend},Int64,Float64,Plots.PlotText})
|
||||
Base.precompile(Tuple{typeof(Plots.process_annotation),Plots.Subplot{Plots.PlotlyBackend},Int64,Float64,Plots.PlotText})
|
||||
Base.precompile(Tuple{typeof(Plots.process_axis_arg!),Dict{Symbol,Any},StepRange{Int64,Int64},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.process_axis_arg!),Dict{Symbol,Any},String,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.process_axis_arg!),Dict{Symbol,Any},Symbol,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.process_axis_arg!),Dict{Symbol,Any},Tuple{Int64,Int64},Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.process_clims),Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.reset_axis_defaults_byletter!)})
|
||||
Base.precompile(Tuple{typeof(Plots.rightpad),Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots.rowsize),Expr})
|
||||
Base.precompile(Tuple{typeof(Plots.rowsize),Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.series_annotations),Array{Any,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Array{Float64,2},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Array{Measures.Length{:mm,Float64},2},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Array{PlotUtils.ContinuousColorGradient,2},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Array{RGBA{Float64},2},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Array{String,2},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Array{Symbol,2},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Bool,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Float64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Function,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Nothing,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),RGBA{Float64},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),StepRange{Int64,Int64},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),String,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Symbol,Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Tuple{Float64,Float64},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Tuple{Int64,Float64},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),Tuple{Int64,Int64},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.slice_arg),UnitRange{Int64},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.straightline_data),Tuple{Float64,Float64},Tuple{Float64,Float64},Array{Float64,1},Array{Float64,1},Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.toppad),Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(Plots.transpose_z),Plots.Series,Array{Float64,2},Bool})
|
||||
Base.precompile(Tuple{typeof(Plots.treats_y_as_x),Array{Symbol,2}})
|
||||
Base.precompile(Tuple{typeof(Plots.update_child_bboxes!),Plots.Subplot{Plots.GRBackend},Array{Measures.Length{:mm,Float64},1}})
|
||||
Base.precompile(Tuple{typeof(Plots.widen),Float64,Float64,Symbol})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Array{Any,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Bool})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Float64})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Int64})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Nothing})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Plots.SeriesAnnotations})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Array{Symbol,2},Int64,Float64,Plots.Stroke}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Array{Symbol,2},Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Int64,Array{Symbol,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Int64,Float64,Symbol,Plots.Stroke}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Int64,Float64,Symbol}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Int64,String}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Int64,Symbol,Float64,Array{Symbol,2}}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Int64,Symbol,Symbol}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Int64,Symbol}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{LinRange{Float64},LinRange{Float64}}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Shape,Int64,RGBA{Float64}}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{String,Symbol}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{String,Tuple{Int64,Int64},StepRange{Int64,Int64},Symbol}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Symbol,Float64,Plots.Stroke}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Symbol,Int64}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Symbol,Symbol,Int64,Symbol,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{Symbol,Symbol,Symbol,Int64,Float64}})
|
||||
Base.precompile(Tuple{typeof(Plots.wraptuple),Tuple{}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Array{Complex{Float64},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Array{GeometryBasics.Point{2,Float64},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Array{OHLC,1}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Plots.PortfolioComposition})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:mesh3d}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Plots.Spy})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:bar}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:bar}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:contour}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:contour}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:heatmap}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:heatmap}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:histogram2d}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:histogram2d}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:histogram}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:histogram}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:hline}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:hline}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:image}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:path}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:path}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:pie}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:pie}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:scatter}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:scatter}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:shape}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:shape}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:spy}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:spy}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:vline}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:vline}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:wireframe}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:wireframe}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:xerror}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:xerror}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:yerror}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:yerror}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:zerror}},Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:zerror}},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:barbins}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:barhist}},Base.OneTo{Int64},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:bar}},Array{Float64,1},Array{Float64,1},Nothing})
|
||||
@@ -306,9 +646,11 @@ function _precompile_()
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:bar}},Base.OneTo{Int64},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:bins2d}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Surface{Array{Float64,2}}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:histogram2d}},Array{Float64,1},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:histogram}},Base.OneTo{Int64},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:hline}},Base.OneTo{Int64},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:line}},Base.OneTo{Int64},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:pie}},Array{String,1},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:steppost}},Array{Float64,1},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:steppre}},Array{Float64,1},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:steppre}},Array{Int64,1},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:steppre}},Base.OneTo{Int64},Array{Float64,1},Nothing})
|
||||
@@ -316,22 +658,59 @@ function _precompile_()
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:vline}},Base.OneTo{Int64},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:xerror}},Array{Float64,1},Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:xerror}},Array{Float64,1},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:yerror}},Array{Float64,1},Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:yerror}},Array{Float64,1},Array{Float64,1},Nothing})
|
||||
Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),RecipesPipeline.DefaultsDict,Type{Val{:zerror}},Array{Float64,1},Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.is_seriestype_supported),Plots.Plot{Plots.GRBackend},Symbol})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.is_seriestype_supported),Plots.Plot{Plots.PlotlyBackend},Symbol})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plots.Plot{Plots.GRBackend},RecipesPipeline.DefaultsDict})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plots.Plot{Plots.PlotlyBackend},RecipesPipeline.DefaultsDict})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plots.Plot{Plots.GRBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plots.Plot{Plots.PlotlyBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.GRBackend},Symbol,Array{Int64,1},Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.GRBackend},Symbol,Array{String,1},Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.GRBackend},Symbol,Array{Symbol,2},Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.GRBackend},Symbol,Plots.GridLayout,Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.GRBackend},Symbol,Plots.Plot{Plots.GRBackend},Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.GRBackend},Symbol,String,Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.GRBackend},Symbol,Symbol,Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.PlotlyBackend},Symbol,Array{Int64,1},Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.PlotlyBackend},Symbol,Array{String,1},Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.PlotlyBackend},Symbol,Array{Symbol,2},Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.PlotlyBackend},Symbol,Plots.GridLayout,Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.PlotlyBackend},Symbol,Plots.Plot{Plots.PlotlyBackend},Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.PlotlyBackend},Symbol,String,Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.splittable_attribute),Plots.Plot{Plots.PlotlyBackend},Symbol,Symbol,Int64})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{AbstractArray{Float64,1},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Array{Float64,1},1},Vararg{Array{Array{Float64,1},1},N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Array{T,1} where T,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Array{T,1} where T,1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Complex{Float64},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Dates.DateTime,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Float64,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Float64,2}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Function,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{GeometryBasics.Point{2,Float64},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Int64,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Int64,1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{OHLC,1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{String,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Tuple{Int64,Int64},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Tuple{Int64,Real},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Array{Union{Missing, Int64},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Formatted{Array{Int64,1}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Function,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Int64,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Nothing,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Plots.PortfolioComposition})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Plots.Spy})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,RecipesPipeline.GroupBy,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,StepRange{Int64,Int64},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Symbol})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,Type{T} where T,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,UnitRange{Int64}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Symbol,Array{AbstractArray{Float64,1},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Symbol,Array{Array{Float64,1},1},Vararg{Array{Array{Float64,1},1},N} where N})
|
||||
@@ -379,18 +758,33 @@ function _precompile_()
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},RecipeData,Symbol,Type{T} where T,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},RecipesPipeline.DefaultsDict,Symbol,Symbol})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{AbstractArray{Float64,1},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Array{Float64,1},1},Vararg{Array{Array{Float64,1},1},N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Array{T,1} where T,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Array{T,1} where T,1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Complex{Float64},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Dates.DateTime,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Float64,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Float64,1},Vararg{Array{Float64,1},N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Float64,2}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Function,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{GeometryBasics.Point{2,Float64},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Int64,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Int64,1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{OHLC,1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{String,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Tuple{Int64,Int64},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Tuple{Int64,Real},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Array{Union{Missing, Int64},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Formatted{Array{Int64,1}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Function,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Nothing,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Plots.PortfolioComposition})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Plots.Spy})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,RecipesPipeline.GroupBy,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,StepRange{Int64,Int64},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Symbol})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,Type{T} where T,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,UnitRange{Int64}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Symbol,Array{AbstractArray{Float64,1},1}})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Symbol,Array{Array{Float64,1},1},Vararg{Array{Array{Float64,1},1},N} where N})
|
||||
@@ -438,25 +832,69 @@ function _precompile_()
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},RecipeData,Symbol,Type{T} where T,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},RecipesPipeline.DefaultsDict,Symbol,Symbol})
|
||||
Base.precompile(Tuple{typeof(annotate!),Array{Tuple{Int64,Float64,Plots.PlotText},1}})
|
||||
Base.precompile(Tuple{typeof(arrow),Int64})
|
||||
Base.precompile(Tuple{typeof(backend),Plots.PlotlyBackend})
|
||||
Base.precompile(Tuple{typeof(bar),Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
|
||||
Base.precompile(Tuple{typeof(bbox),Measures.Length{:mm,Float64},Measures.Length{:mm,Float64},Measures.Length{:mm,Float64},Measures.Length{:mm,Float64}})
|
||||
Base.precompile(Tuple{typeof(contour),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(convert),Type{AbstractBackend},Plots.PlotlyBackend})
|
||||
Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_colorgradient),Tuple{Array{Any,1}}}})
|
||||
Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_fillalpha),Tuple{Array{Any,1}}}})
|
||||
Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linealpha),Tuple{Array{Any,1}}}})
|
||||
Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linestyle),Tuple{Array{Any,1}}}})
|
||||
Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linewidth),Tuple{Array{Any,1}}}})
|
||||
Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.gr_color),Tuple{Array{RGBA{Float64},1}}}})
|
||||
Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.gr_tick_label),Tuple{Tuple{Plots.Axis},Array{String,1}}}})
|
||||
Base.precompile(Tuple{typeof(copyto!),Array{Any,1},Tuple{String,String,String,String,String,Plots.PlotText}})
|
||||
Base.precompile(Tuple{typeof(deepcopy),Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(deepcopy),Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(default),Symbol,Bool})
|
||||
Base.precompile(Tuple{typeof(default),Symbol,Int64})
|
||||
Base.precompile(Tuple{typeof(default),Symbol,String})
|
||||
Base.precompile(Tuple{typeof(default),Symbol,Symbol})
|
||||
Base.precompile(Tuple{typeof(enumerate),Tuple{Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}}})
|
||||
Base.precompile(Tuple{typeof(enumerate),Tuple{Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}}})
|
||||
Base.precompile(Tuple{typeof(enumerate),Tuple{Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}}})
|
||||
Base.precompile(Tuple{typeof(enumerate),Tuple{Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}}})
|
||||
Base.precompile(Tuple{typeof(font),String,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(frame),Animation,Plots.Plot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(get),Dict{Plots.Subplot,Any},Plots.Subplot{Plots.GRBackend},Dict{Symbol,Any}})
|
||||
Base.precompile(Tuple{typeof(get),Dict{Plots.Subplot,Any},Plots.Subplot{Plots.PlotlyBackend},Dict{Symbol,Any}})
|
||||
Base.precompile(Tuple{typeof(get),RecipesPipeline.DefaultsDict,Symbol,Plots.Arrow})
|
||||
Base.precompile(Tuple{typeof(get),RecipesPipeline.DefaultsDict,Symbol,Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(get),RecipesPipeline.DefaultsDict,Symbol,Plots.Subplot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(getproperty),Plots.Arrow,Symbol})
|
||||
Base.precompile(Tuple{typeof(getproperty),Plots.SeriesAnnotations,Symbol})
|
||||
Base.precompile(Tuple{typeof(haskey),Dict{Symbol,Symbol},Shape})
|
||||
Base.precompile(Tuple{typeof(heatmap),Array{Dates.DateTime,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(iter_segments),Array{Float64,1},Array{Float64,1},UnitRange{Int64}})
|
||||
Base.precompile(Tuple{typeof(iter_segments),Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(in),Plots.Arrow,Tuple{Bool,Nothing,Symbol}})
|
||||
Base.precompile(Tuple{typeof(in),Plots.Subplot{Plots.GRBackend},Array{Plots.Subplot,1}})
|
||||
Base.precompile(Tuple{typeof(in),Plots.Subplot{Plots.PlotlyBackend},Array{Plots.Subplot,1}})
|
||||
Base.precompile(Tuple{typeof(iter_segments),Array{Float64,1},Array{Float64,1},Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(iter_segments),Array{Float64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(iter_segments),Array{Int64,1},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(iter_segments),Base.OneTo{Int64},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(iter_segments),Base.OneTo{Int64},UnitRange{Int64}})
|
||||
Base.precompile(Tuple{typeof(iter_segments),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(iter_segments),StepRange{Int64,Int64},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(iter_segments),UnitRange{Int64},Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(iterate),Base.Iterators.Enumerate{Tuple{Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}}},Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(iterate),Base.Iterators.Enumerate{Tuple{Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}}},Tuple{Int64}})
|
||||
Base.precompile(Tuple{typeof(iterate),Base.Iterators.Enumerate{Tuple{Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}}},Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(iterate),Base.Iterators.Enumerate{Tuple{Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}}},Tuple{Int64}})
|
||||
Base.precompile(Tuple{typeof(iterate),Base.Iterators.Enumerate{Tuple{Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}}},Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(iterate),Base.Iterators.Enumerate{Tuple{Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}}},Tuple{Int64}})
|
||||
Base.precompile(Tuple{typeof(iterate),Base.Iterators.Enumerate{Tuple{Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}}},Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(iterate),Base.Iterators.Enumerate{Tuple{Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}}},Tuple{Int64}})
|
||||
Base.precompile(Tuple{typeof(ohlc),Array{OHLC,1}})
|
||||
Base.precompile(Tuple{typeof(plot!),Array{Float64,2}})
|
||||
Base.precompile(Tuple{typeof(plot!),Array{Tuple{Int64,Real},1}})
|
||||
Base.precompile(Tuple{typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Float64,2}})
|
||||
Base.precompile(Tuple{typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Tuple{Int64,Real},1}})
|
||||
Base.precompile(Tuple{typeof(plot!),Plots.Plot{Plots.PlotlyBackend},Array{Float64,2}})
|
||||
Base.precompile(Tuple{typeof(plot!),Plots.Plot{Plots.PlotlyBackend},Array{Tuple{Int64,Real},1}})
|
||||
Base.precompile(Tuple{typeof(plot),Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(plot),Array{Tuple{Int64,Int64},1}})
|
||||
Base.precompile(Tuple{typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Vararg{Plots.Plot{Plots.GRBackend},N} where N})
|
||||
Base.precompile(Tuple{typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}})
|
||||
@@ -465,8 +903,53 @@ function _precompile_()
|
||||
Base.precompile(Tuple{typeof(plot),Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Function})
|
||||
Base.precompile(Tuple{typeof(push!),Plots.Plot{Plots.GRBackend},Float64,Array{Float64,1}})
|
||||
Base.precompile(Tuple{typeof(push!),Segments{Float64},Float64,Float64,Float64,Float64,Vararg{Float64,N} where N})
|
||||
Base.precompile(Tuple{typeof(push!),Segments{Float64},Float64,Int64,Int64,Float64,Vararg{Float64,N} where N})
|
||||
Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64,Float64,Float64}},Tuple{Float64,Float64,Float64},Tuple{Float64,Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64,Float64}},Tuple{Float64,Float64},Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64,Float64}},Tuple{Float64,Int64},Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64,Float64}},Tuple{Float64,Int64},Tuple{Float64,Int64}})
|
||||
Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64,Float64}},Tuple{Int64,Float64},Tuple{Float64,Float64}})
|
||||
Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64,Float64}},Tuple{Int64,Float64},Tuple{Int64,Float64}})
|
||||
Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64,Float64}},Tuple{Int64,Int64},Tuple{Float64,Int64}})
|
||||
Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64,Float64}},Tuple{Int64,Int64},Tuple{Int64,Int64}})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Any,Any},Plots.Plot{Plots.GRBackend},Int64})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Any,Any},Plots.Plot{Plots.PlotlyBackend},Int64})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Any,Plots.Subplot},Plots.Subplot{Plots.GRBackend},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Any,Plots.Subplot},Plots.Subplot{Plots.PlotlyBackend},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Plots.Subplot,Any},Dict{Symbol,Any},Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Plots.Subplot,Any},Dict{Symbol,Any},Plots.Subplot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Symbol,Any},Plots.Arrow,Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Symbol,Any},Plots.GridLayout,Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Symbol,Any},Plots.Subplot{Plots.GRBackend},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Symbol,Any},Plots.Subplot{Plots.PlotlyBackend},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Symbol,Any},Tuple{Array{Symbol,2},Int64,Float64,Plots.Stroke},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Symbol,Any},Tuple{Int64,Float64,Plots.PlotText},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Symbol,Any},Tuple{Int64,Float64,Symbol,Plots.Stroke},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Symbol,Any},Tuple{Shape,Int64,RGBA{Float64}},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Dict{Symbol,Any},Tuple{Symbol,Float64,Plots.Stroke},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Plots.Axis,Array{Any,1},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Plots.Axis,Array{Float64,1},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Plots.Axis,Dict{Any,Any},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Plots.Axis,Plots.Extrema,Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Plots.GridLayout,Plots.EmptyLayout,Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(setindex!),Plots.GridLayout,Plots.GridLayout,Int64,Int64})
|
||||
Base.precompile(Tuple{typeof(setindex!),Plots.Plot{Plots.GRBackend},RGBA{Float64},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),Plots.Plot{Plots.PlotlyBackend},RGBA{Float64},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),RecipesPipeline.DefaultsDict,Array{Tuple{Int64,Float64,Plots.PlotText},1},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),RecipesPipeline.DefaultsDict,Plots.Arrow,Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),RecipesPipeline.DefaultsDict,Plots.GridLayout,Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),RecipesPipeline.DefaultsDict,Plots.Subplot{Plots.GRBackend},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),RecipesPipeline.DefaultsDict,Plots.Subplot{Plots.PlotlyBackend},Symbol})
|
||||
Base.precompile(Tuple{typeof(setindex!),RecipesPipeline.DefaultsDict,Tuple{Int64,Float64,Plots.PlotText},Symbol})
|
||||
Base.precompile(Tuple{typeof(setproperty!),Plots.GridLayout,Symbol,Measures.BoundingBox{Tuple{Measures.Length{:mm,Float64},Measures.Length{:mm,Float64}},Tuple{Measures.Length{:mm,Float64},Measures.Length{:mm,Float64}}}})
|
||||
Base.precompile(Tuple{typeof(similar),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.contour_levels),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}},Base.RefValue{Tuple{Float64,Float64}}}},Type{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}})
|
||||
Base.precompile(Tuple{typeof(similar),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_colorgradient),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}}}},Type{PlotUtils.ContinuousColorGradient}})
|
||||
Base.precompile(Tuple{typeof(similar),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_fillalpha),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}}}},Type{Nothing}})
|
||||
Base.precompile(Tuple{typeof(similar),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linealpha),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}}}},Type{Nothing}})
|
||||
Base.precompile(Tuple{typeof(similar),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linecolor),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}},Base.RefValue{Tuple{Float64,Float64}}}},Type{PlotUtils.ContinuousColorGradient}})
|
||||
Base.precompile(Tuple{typeof(similar),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linestyle),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}}}},Type{Symbol}})
|
||||
Base.precompile(Tuple{typeof(similar),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linewidth),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}}}},Type{Int64}})
|
||||
Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(text),String,Int64,Symbol,Vararg{Symbol,N} where N})
|
||||
Base.precompile(Tuple{typeof(text),String,Symbol,Int64,Vararg{Any,N} where N})
|
||||
@@ -475,8 +958,19 @@ function _precompile_()
|
||||
Base.precompile(Tuple{typeof(vcat),Array{Any,1},Tuple{Int64,Float64,Plots.PlotText}})
|
||||
Base.precompile(Tuple{typeof(vline!),Array{Int64,1}})
|
||||
Base.precompile(Tuple{typeof(xgrid!),Plots.Plot{Plots.GRBackend},Symbol,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(xgrid!),Plots.Plot{Plots.PlotlyBackend},Symbol,Vararg{Any,N} where N})
|
||||
Base.precompile(Tuple{typeof(xlims),Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(xlims),Plots.Subplot{Plots.PlotlyBackend}})
|
||||
Base.precompile(Tuple{typeof(yaxis!),String,Symbol})
|
||||
Base.precompile(Tuple{typeof(ylims),Plots.Subplot{Plots.GRBackend}})
|
||||
Base.precompile(Tuple{typeof(ylims),Plots.Subplot{Plots.PlotlyBackend}})
|
||||
isdefined(Plots, Symbol("#142#143")) && Base.precompile(Tuple{getfield(Plots, Symbol("#142#143")),Tuple{Int64,Expr}})
|
||||
isdefined(Plots, Symbol("#142#143")) && Base.precompile(Tuple{getfield(Plots, Symbol("#142#143")),Tuple{Int64,Symbol}})
|
||||
isdefined(Plots, Symbol("#144#145")) && Base.precompile(Tuple{getfield(Plots, Symbol("#144#145")),Tuple{Int64,Expr}})
|
||||
isdefined(Plots, Symbol("#144#145")) && Base.precompile(Tuple{getfield(Plots, Symbol("#144#145")),Tuple{Int64,Symbol}})
|
||||
isdefined(Plots, Symbol("#146#147")) && Base.precompile(Tuple{getfield(Plots, Symbol("#146#147")),Plots.Subplot{Plots.GRBackend}})
|
||||
isdefined(Plots, Symbol("#146#147")) && Base.precompile(Tuple{getfield(Plots, Symbol("#146#147")),Plots.Subplot{Plots.PlotlyBackend}})
|
||||
isdefined(Plots, Symbol("#279#312")) && Base.precompile(Tuple{getfield(Plots, Symbol("#279#312"))})
|
||||
let fbody = try __lookup_kwbody__(which(Plots.GridLayout, (Int64,Vararg{Int64,N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Plots.RootLayout,Array{Float64,1},Array{Float64,1},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},Type{Plots.GridLayout},Int64,Vararg{Int64,N} where N,))
|
||||
@@ -487,6 +981,16 @@ function _precompile_()
|
||||
precompile(fbody, (Symbol,Symbol,typeof(Plots.gr_polyline),Array{Float64,1},Array{Float64,1},typeof(GR.fillarea),))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(Plots.gr_set_font, (Plots.Font,Plots.Subplot{Plots.GRBackend},))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Symbol,Symbol,RGBA{Float64},Float64,typeof(Plots.gr_set_font),Plots.Font,Plots.Subplot{Plots.GRBackend},))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(Plots.gr_set_font, (Plots.Font,Plots.Subplot{Plots.GRBackend},))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Symbol,Symbol,RGBA{Float64},Int64,typeof(Plots.gr_set_font),Plots.Font,Plots.Subplot{Plots.GRBackend},))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(Plots.text, (String,Int64,Vararg{Any,N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(text),String,Int64,Vararg{Any,N} where N,))
|
||||
@@ -572,9 +1076,29 @@ function _precompile_()
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Any,NTuple{5,Symbol},NamedTuple{(:zcolor, :m, :leg, :cbar, :w),Tuple{StepRange{Int64,Int64},Tuple{Int64,Float64,Symbol,Plots.Stroke},Bool,Bool,Int64}}},typeof(plot),Array{Float64,1},Vararg{Any,N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Array{Float64,1},Vararg{Array{Float64,1},N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Any,Tuple{Symbol,Symbol,Symbol},NamedTuple{(:line_z, :linewidth, :legend),Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Int64,Bool}}},typeof(plot),Array{Float64,1},Vararg{Array{Float64,1},N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Array{Float64,1},Vararg{Array{Float64,1},N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Int64,Tuple{Symbol},NamedTuple{(:arrow,),Tuple{Int64}}},typeof(plot),Array{Float64,1},Vararg{Array{Float64,1},N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Array{Function,1},Vararg{Any,N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Any,Tuple{Symbol,Symbol,Symbol},NamedTuple{(:leg, :xlims, :ylims),Tuple{Bool,Tuple{Int64,Float64},Tuple{Int64,Int64}}}},typeof(plot),Array{Function,1},Vararg{Any,N} where N,))
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Any,NTuple{5,Symbol},NamedTuple{(:label, :title, :xlabel, :linewidth, :legend),Tuple{Array{String,2},String,String,Int64,Symbol}}},typeof(plot),Array{Function,1},Vararg{Any,N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Array{Function,1},Vararg{Any,N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Any,Tuple{Symbol,Symbol},NamedTuple{(:leg, :seriestype),Tuple{Bool,Symbol}}},typeof(plot),Array{Function,1},Vararg{Any,N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Array{Function,1},Vararg{Any,N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Bool,Tuple{Symbol},NamedTuple{(:leg,),Tuple{Bool}}},typeof(plot),Array{Function,1},Vararg{Any,N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Function,Vararg{Any,N} where N,))) catch missing end
|
||||
@@ -582,6 +1106,26 @@ function _precompile_()
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Any,Tuple{Symbol,Symbol,Symbol},NamedTuple{(:line, :leg, :fill),Tuple{Int64,Bool,Tuple{Int64,Symbol}}}},typeof(plot),Function,Vararg{Any,N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Function,Vararg{Any,N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Any,Tuple{Symbol,Symbol,Symbol},NamedTuple{(:xlims, :ylims, :leg),Tuple{Tuple{Int64,Float64},Tuple{Int64,Int64},Bool}}},typeof(plot),Function,Vararg{Any,N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Any,NTuple{7,Symbol},NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg),Tuple{Tuple{Int64,Symbol,Symbol},Tuple{Shape,Int64,RGBA{Float64}},Symbol,Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Bool}}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Any,Tuple{Symbol,Symbol},NamedTuple{(:proj, :m),Tuple{Symbol,Int64}}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N,))
|
||||
end
|
||||
end
|
||||
let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (StepRange{Int64,Int64},Vararg{Any,N} where N,))) catch missing end
|
||||
if !ismissing(fbody)
|
||||
precompile(fbody, (Base.Iterators.Pairs{Symbol,Any,NTuple{5,Symbol},NamedTuple{(:lab, :w, :palette, :fill, :α),Tuple{String,Int64,PlotUtils.ContinuousColorGradient,Int64,Float64}}},typeof(plot),StepRange{Int64,Int64},Vararg{Any,N} where N,))
|
||||
|
||||
+1131
-580
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
+3
-2
@@ -993,9 +993,9 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
|
||||
end
|
||||
end
|
||||
|
||||
# vline and others accesses the y argument but actually maps it to the x axis.
|
||||
# vline accesses the y argument but actually maps it to the x axis.
|
||||
# Hence, we have to swap formatters
|
||||
if treats_y_as_x(get(plotattributes, :seriestype, :path))
|
||||
if get(plotattributes, :seriestype, :path) == :vline
|
||||
xformatter = get(plotattributes, :xformatter, :auto)
|
||||
yformatter = get(plotattributes, :yformatter, :auto)
|
||||
plotattributes[:xformatter] = yformatter
|
||||
@@ -1145,6 +1145,7 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
|
||||
if st in (:boxplot, :violin, :density) && !isdefined(Main, :StatsPlots)
|
||||
@warn("seriestype $st has been moved to StatsPlots. To use: \`Pkg.add(\"StatsPlots\"); using StatsPlots\`")
|
||||
end
|
||||
|
||||
return
|
||||
end
|
||||
|
||||
|
||||
@@ -123,14 +123,6 @@ const _label_func = Dict{Symbol,Function}(
|
||||
)
|
||||
labelfunc(scale::Symbol, backend::AbstractBackend) = get(_label_func, scale, string)
|
||||
|
||||
const _label_func_tex = Dict{Symbol,Function}(
|
||||
:log10 => x -> "10^{$x}",
|
||||
:log2 => x -> "2^{$x}",
|
||||
:ln => x -> "e^{$x}",
|
||||
)
|
||||
labelfunc_tex(scale::Symbol) = get(_label_func_tex, scale, convert_sci_unicode)
|
||||
|
||||
|
||||
function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
|
||||
amin, amax = axis_limits(sp, axis[:letter])
|
||||
|
||||
|
||||
@@ -665,6 +665,11 @@ mutable struct HDF5Plot_PlotRef
|
||||
end
|
||||
const HDF5PLOT_PLOTREF = HDF5Plot_PlotRef(nothing)
|
||||
|
||||
#Simple sub-structures that can just be written out using _hdf5plot_gwritefields:
|
||||
const HDF5PLOT_SIMPLESUBSTRUCT = Union{Font, BoundingBox,
|
||||
GridLayout, RootLayout, ColorGradient, SeriesAnnotations, PlotText,
|
||||
Shape,
|
||||
}
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# inspectdr
|
||||
|
||||
+34
-25
@@ -182,9 +182,9 @@ function gr_polyline3d(x, y, z, func = GR.polyline3d)
|
||||
end
|
||||
end
|
||||
|
||||
gr_inqtext(x, y, s) = gr_inqtext(x, y, string(s))
|
||||
gr_inqtext(x, y, s::Symbol) = gr_inqtext(x, y, string(s))
|
||||
|
||||
function gr_inqtext(x, y, s::AbstractString)
|
||||
function gr_inqtext(x, y, s)
|
||||
if length(s) >= 2 && s[1] == '$' && s[end] == '$'
|
||||
GR.inqmathtex(x, y, s[2:end-1])
|
||||
elseif findfirst(isequal('\\'), s) !== nothing || occursin("10^{", s)
|
||||
@@ -194,9 +194,9 @@ function gr_inqtext(x, y, s::AbstractString)
|
||||
end
|
||||
end
|
||||
|
||||
gr_text(x, y, s) = gr_text(x, y, string(s))
|
||||
gr_text(x, y, s::Symbol) = gr_text(x, y, string(s))
|
||||
|
||||
function gr_text(x, y, s::AbstractString)
|
||||
function gr_text(x, y, s)
|
||||
if length(s) >= 2 && s[1] == '$' && s[end] == '$'
|
||||
GR.mathtex(x, y, s[2:end-1])
|
||||
elseif findfirst(isequal('\\'), s) !== nothing || occursin("10^{", s)
|
||||
@@ -216,6 +216,7 @@ function gr_polaraxes(rmin::Real, rmax::Real, sp::Subplot)
|
||||
sinf = sind.(a)
|
||||
cosf = cosd.(a)
|
||||
rtick_values, rtick_labels = get_ticks(sp, yaxis)
|
||||
rtick_labels = gr_tick_label.((yaxis,), rtick_labels)
|
||||
|
||||
#draw angular grid
|
||||
if xaxis[:grid]
|
||||
@@ -348,15 +349,12 @@ function gr_draw_markers(
|
||||
|
||||
shapes = series[:markershape]
|
||||
if shapes != :none
|
||||
for (i, rng) in enumerate(iter_segments(series, :scatter))
|
||||
rng = intersect(eachindex(x), rng)
|
||||
if !isempty(rng)
|
||||
ms = get_thickness_scaling(series) * _cycle(msize, i)
|
||||
msw = get_thickness_scaling(series) * _cycle(strokewidth, i)
|
||||
shape = _cycle(shapes, i)
|
||||
for j in rng
|
||||
gr_draw_marker(series, _cycle(x, j), _cycle(y, j), clims, i, ms, msw, shape)
|
||||
end
|
||||
for (i, rng) in enumerate(iter_segments(series))
|
||||
ms = get_thickness_scaling(series) * _cycle(msize, i)
|
||||
msw = get_thickness_scaling(series) * _cycle(strokewidth, i)
|
||||
shape = _cycle(shapes, i)
|
||||
for j in rng
|
||||
gr_draw_marker(series, _cycle(x, j), _cycle(y, j), clims, i, ms, msw, shape)
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -748,10 +746,20 @@ function gr_get_ticks_size(ticks, rot)
|
||||
return w, h
|
||||
end
|
||||
|
||||
function labelfunc(scale::Symbol, backend::GRBackend)
|
||||
texfunc = labelfunc_tex(scale)
|
||||
# replace dash with \minus (U+2212)
|
||||
label -> replace(texfunc(label), "-" => "−")
|
||||
gr_tick_label(axis, label) =
|
||||
(axis[:formatter] in (:scientific, :auto)) ? gr_convert_sci_tick_label(string(label)) :
|
||||
string(label)
|
||||
|
||||
function gr_convert_sci_tick_label(label)
|
||||
caret_split = split(label,'^')
|
||||
if length(caret_split) == 2
|
||||
base, exponent = caret_split
|
||||
label = "$base^{$exponent}"
|
||||
end
|
||||
if occursin("×10", label)
|
||||
label = string(replace(label, "×10" => "×10^{"), "}")
|
||||
end
|
||||
label
|
||||
end
|
||||
|
||||
function gr_axis_height(sp, axis)
|
||||
@@ -1280,7 +1288,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
|
||||
xi, yi = gr_w3tondc(cv, yt, zt)
|
||||
xi += (yaxis[:mirror] ? 1 : -1) * 1e-2 * (xaxis[:tick_direction] == :out ? 1.5 : 1.0)
|
||||
yi += (xaxis[:mirror] ? 1 : -1) * 5e-3 * (xaxis[:tick_direction] == :out ? 1.5 : 1.0)
|
||||
gr_text(xi, yi, dv)
|
||||
gr_text(xi, yi, gr_tick_label(xaxis, dv))
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1312,7 +1320,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
|
||||
xi, yi = gr_w3tondc(xt, cv, zt)
|
||||
gr_text(xi + (yaxis[:mirror] ? -1 : 1) * 1e-2 * (yaxis[:tick_direction] == :out ? 1.5 : 1.0),
|
||||
yi + (yaxis[:mirror] ? 1 : -1) * 5e-3 * (yaxis[:tick_direction] == :out ? 1.5 : 1.0),
|
||||
dv)
|
||||
gr_tick_label(yaxis, dv))
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1343,7 +1351,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
|
||||
for (cv, dv) in zip(zticks...)
|
||||
xi, yi = gr_w3tondc(xt, yt, cv)
|
||||
gr_text(xi + (zaxis[:mirror] ? 1 : -1) * 1e-2 * (zaxis[:tick_direction] == :out ? 1.5 : 1.0),
|
||||
yi, dv)
|
||||
yi, gr_tick_label(zaxis, dv))
|
||||
end
|
||||
end
|
||||
#
|
||||
@@ -1463,7 +1471,8 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
|
||||
flip, mirror = gr_set_xticks_font(sp)
|
||||
for (cv, dv) in zip(xticks...)
|
||||
xi, yi = GR.wctondc(cv, sp[:framestyle] == :origin ? 0 : xor(flip, mirror) ? ymax : ymin)
|
||||
gr_text(xi, yi + (mirror ? 1 : -1) * 5e-3 * (xaxis[:tick_direction] == :out ? 1.5 : 1.0), dv)
|
||||
gr_text(xi, yi + (mirror ? 1 : -1) * 5e-3 * (xaxis[:tick_direction] == :out ? 1.5 : 1.0),
|
||||
gr_tick_label(xaxis, dv))
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1473,8 +1482,8 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
|
||||
for (cv, dv) in zip(yticks...)
|
||||
xi, yi = GR.wctondc(sp[:framestyle] == :origin ? 0 : xor(flip, mirror) ? xmax : xmin, cv)
|
||||
gr_text(xi + (mirror ? 1 : -1) * 1e-2 * (yaxis[:tick_direction] == :out ? 1.5 : 1.0),
|
||||
yi, dv)
|
||||
|
||||
yi,
|
||||
gr_tick_label(yaxis, dv))
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1637,7 +1646,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
|
||||
if st in (:path, :scatter, :straightline)
|
||||
if x !== nothing && length(x) > 1
|
||||
lz = series[:line_z]
|
||||
segments = iter_segments(series, st)
|
||||
segments = iter_segments(series)
|
||||
# do area fill
|
||||
if frng !== nothing
|
||||
GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
||||
@@ -1762,7 +1771,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
|
||||
if st == :path3d
|
||||
if length(x) > 1
|
||||
lz = series[:line_z]
|
||||
segments = iter_segments(series, st)
|
||||
segments = iter_segments(series)
|
||||
for (i, rng) in enumerate(segments)
|
||||
lc = get_linecolor(series, clims, i)
|
||||
gr_set_line(
|
||||
|
||||
+485
-492
File diff suppressed because it is too large
Load Diff
+261
-273
@@ -287,11 +287,129 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
|
||||
!isfilledcontour(series) && series[:ribbon] === nothing
|
||||
push!(series_opt, "area legend" => nothing)
|
||||
end
|
||||
pgfx_add_series!(Val(st), axis, series_opt, series, series_func, opt)
|
||||
if extra_series !== nothing
|
||||
extra_series = wraptuple(extra_series)
|
||||
push!(axis.contents[end], extra_series...)
|
||||
if st in (:heatmap, :contour)
|
||||
push!(axis.options, "view" => "{0}{90}")
|
||||
end
|
||||
# treat segments
|
||||
segments =
|
||||
if st in (:wireframe, :heatmap, :contour, :surface, :contour3d)
|
||||
iter_segments(surface_to_vecs(
|
||||
series[:x],
|
||||
series[:y],
|
||||
series[:z],
|
||||
)...)
|
||||
else
|
||||
iter_segments(series)
|
||||
end
|
||||
for (i, rng) in enumerate(segments)
|
||||
segment_opt = PGFPlotsX.Options()
|
||||
segment_opt = merge(segment_opt, pgfx_linestyle(opt, i))
|
||||
if opt[:markershape] != :none
|
||||
marker = opt[:markershape]
|
||||
if marker isa Shape
|
||||
x = marker.x
|
||||
y = marker.y
|
||||
scale_factor = 0.00125
|
||||
mark_size = opt[:markersize] * scale_factor
|
||||
path = join(
|
||||
[
|
||||
"($(x[i] * mark_size), $(y[i] * mark_size))"
|
||||
for i in eachindex(x)
|
||||
],
|
||||
" -- ",
|
||||
)
|
||||
c = get_markercolor(series, i)
|
||||
a = get_markeralpha(series, i)
|
||||
PGFPlotsX.push_preamble!(
|
||||
pgfx_plot.the_plot,
|
||||
"""
|
||||
\\pgfdeclareplotmark{PlotsShape$(series_index)}{
|
||||
\\filldraw
|
||||
$path;
|
||||
}
|
||||
""",
|
||||
)
|
||||
end
|
||||
segment_opt = merge(segment_opt, pgfx_marker(opt, i))
|
||||
end
|
||||
if st == :shape
|
||||
segment_opt = merge(segment_opt, pgfx_fillstyle(opt, i))
|
||||
end
|
||||
# add fillrange
|
||||
if sf !== nothing &&
|
||||
!isfilledcontour(series)
|
||||
if sf isa Number || sf isa AVec
|
||||
pgfx_fillrange_series!(
|
||||
axis,
|
||||
series,
|
||||
series_func,
|
||||
i,
|
||||
_cycle(sf, rng),
|
||||
rng,
|
||||
)
|
||||
elseif sf isa Tuple && series[:ribbon] !== nothing
|
||||
for sfi in sf
|
||||
pgfx_fillrange_series!(
|
||||
axis,
|
||||
series,
|
||||
series_func,
|
||||
i,
|
||||
_cycle(sfi, rng),
|
||||
rng,
|
||||
)
|
||||
end
|
||||
end
|
||||
if i == 1 &&
|
||||
sp[:legend] != :none && pgfx_should_add_to_legend(series)
|
||||
pgfx_filllegend!(series_opt, opt)
|
||||
end
|
||||
end
|
||||
coordinates =
|
||||
pgfx_series_coordinates!(sp, series, segment_opt, opt, rng)
|
||||
segment_plot =
|
||||
series_func(merge(series_opt, segment_opt), coordinates)
|
||||
if extra_series !== nothing
|
||||
extra_series = wraptuple(extra_series)
|
||||
push!(segment_plot, extra_series...)
|
||||
end
|
||||
push!(axis, segment_plot)
|
||||
# fill between functions
|
||||
if sf isa Tuple && series[:ribbon] === nothing
|
||||
sf1, sf2 = sf
|
||||
@assert sf1 == series_index "First index of the tuple has to match the current series index."
|
||||
push!(
|
||||
axis,
|
||||
series_func(
|
||||
merge(
|
||||
pgfx_fillstyle(opt, series_index),
|
||||
PGFPlotsX.Options("forget plot" => nothing),
|
||||
),
|
||||
"fill between [of=$series_id and $(_pgfplotsx_series_ids[Symbol(string(sf2))])]",
|
||||
),
|
||||
)
|
||||
end
|
||||
# add to legend?
|
||||
if sp[:legend] != :none
|
||||
leg_entry = if opt[:label] isa AVec
|
||||
get(opt[:label], i, "")
|
||||
elseif opt[:label] isa AbstractString
|
||||
if i == 1
|
||||
get(opt, :label, "")
|
||||
else
|
||||
""
|
||||
end
|
||||
else
|
||||
throw(ArgumentError("Malformed label. label = $(opt[:label])"))
|
||||
end
|
||||
if leg_entry == "" || !pgfx_should_add_to_legend(series)
|
||||
push!(axis.contents[end].options, "forget plot" => nothing)
|
||||
else
|
||||
leg_opt = PGFPlotsX.Options()
|
||||
legend = PGFPlotsX.LegendEntry(leg_opt, leg_entry, false)
|
||||
push!(axis, legend)
|
||||
end
|
||||
end
|
||||
end # for segments
|
||||
# add series annotations
|
||||
anns = series[:series_annotations]
|
||||
for (xi, yi, str, fnt) in EachAnn(anns, series[:x], series[:y])
|
||||
@@ -325,271 +443,10 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
|
||||
return pgfx_plot
|
||||
end
|
||||
## seriestype specifics
|
||||
function pgfx_add_series!(axis, series_opt, series, series_func, opt)
|
||||
args = pgfx_series_arguments(series, opt)
|
||||
series_plot = series_func(series_opt, PGFPlotsX.Coordinates(args...))
|
||||
push!(axis, series_plot)
|
||||
pgfx_add_legend!(axis, series, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, opt)
|
||||
# treat segments
|
||||
segments = iter_segments(series, series[:seriestype])
|
||||
sf = opt[:fillrange]
|
||||
for (i, rng) in enumerate(segments)
|
||||
segment_opt = PGFPlotsX.Options()
|
||||
segment_opt = merge(segment_opt, pgfx_linestyle(opt, i))
|
||||
if opt[:markershape] != :none
|
||||
marker = _cycle(opt[:markershape], i)
|
||||
if marker isa Shape
|
||||
x = marker.x
|
||||
y = marker.y
|
||||
scale_factor = 0.00125
|
||||
mark_size = opt[:markersize] * scale_factor
|
||||
path = join(
|
||||
[
|
||||
"($(x[i] * mark_size), $(y[i] * mark_size))"
|
||||
for i in eachindex(x)
|
||||
],
|
||||
" -- ",
|
||||
)
|
||||
c = get_markercolor(series, i)
|
||||
a = get_markeralpha(series, i)
|
||||
PGFPlotsX.push_preamble!(
|
||||
series[:plot_object].o.the_plot,
|
||||
"""
|
||||
\\pgfdeclareplotmark{PlotsShape$(series[:series_plotindex])}{
|
||||
\\filldraw
|
||||
$path;
|
||||
}
|
||||
""",
|
||||
)
|
||||
end
|
||||
segment_opt = merge(segment_opt, pgfx_marker(opt, i))
|
||||
end
|
||||
# add fillrange
|
||||
if sf !== nothing &&
|
||||
!isfilledcontour(series)
|
||||
if sf isa Number || sf isa AVec
|
||||
pgfx_fillrange_series!(
|
||||
axis,
|
||||
series,
|
||||
series_func,
|
||||
i,
|
||||
_cycle(sf, rng),
|
||||
rng,
|
||||
)
|
||||
elseif sf isa Tuple && series[:ribbon] !== nothing
|
||||
for sfi in sf
|
||||
pgfx_fillrange_series!(
|
||||
axis,
|
||||
series,
|
||||
series_func,
|
||||
i,
|
||||
_cycle(sfi, rng),
|
||||
rng,
|
||||
)
|
||||
end
|
||||
end
|
||||
if i == 1 &&
|
||||
series[:subplot][:legend] != :none && pgfx_should_add_to_legend(series)
|
||||
pgfx_filllegend!(series_opt, opt)
|
||||
end
|
||||
end
|
||||
coordinates = PGFPlotsX.Table(pgfx_series_arguments(series, opt, rng)...)
|
||||
segment_plot =
|
||||
series_func(merge(series_opt, segment_opt), coordinates)
|
||||
push!(axis, segment_plot)
|
||||
# fill between functions
|
||||
if sf isa Tuple && series[:ribbon] === nothing
|
||||
sf1, sf2 = sf
|
||||
@assert sf1 == series_index "First index of the tuple has to match the current series index."
|
||||
push!(
|
||||
axis,
|
||||
series_func(
|
||||
merge(
|
||||
pgfx_fillstyle(opt, series_index),
|
||||
PGFPlotsX.Options("forget plot" => nothing),
|
||||
),
|
||||
"fill between [of=$series_id and $(_pgfplotsx_series_ids[Symbol(string(sf2))])]",
|
||||
),
|
||||
)
|
||||
end
|
||||
pgfx_add_legend!(axis, series, opt, i)
|
||||
end # for segments
|
||||
# get that last marker
|
||||
if !any(isnan, opt[:y]) && opt[:markershape] isa AVec
|
||||
additional_plot = PGFPlotsX.PlotInc(pgfx_marker(opt, length(segments) + 1), PGFPlotsX.Coordinates(tuple((last(opt[:x]), last(opt[:y])))))
|
||||
push!(axis, additional_plot)
|
||||
end
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:scatter}, axis, series_opt, series, series_func, opt)
|
||||
push!(series_opt, "only marks" => nothing)
|
||||
pgfx_add_series!(Val(:path), axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:straightline}, axis, series_opt, series, series_func, opt)
|
||||
pgfx_add_series!(Val(:path), axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:path3d}, axis, series_opt, series, series_func, opt)
|
||||
pgfx_add_series!(Val(:path), axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:scatter3d}, axis, series_opt, series, series_func, opt)
|
||||
push!(series_opt, "only marks" => nothing)
|
||||
pgfx_add_series!(Val(:path), axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:surface}, axis, series_opt, series, series_func, opt)
|
||||
push!(
|
||||
series_opt,
|
||||
"surf" => nothing,
|
||||
"mesh/rows" => length(opt[:x]),
|
||||
"mesh/cols" => length(opt[:y]),
|
||||
"z buffer" => "sort",
|
||||
)
|
||||
pgfx_add_series!(axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:wireframe}, axis, series_opt, series, series_func, opt)
|
||||
push!(series_opt, "mesh" => nothing,
|
||||
"mesh/rows" => length(opt[:x])
|
||||
)
|
||||
pgfx_add_series!(axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:heatmap}, axis, series_opt, series, series_func, opt)
|
||||
push!(axis.options, "view" => "{0}{90}")
|
||||
push!(
|
||||
series_opt,
|
||||
"matrix plot*" => nothing,
|
||||
"mesh/rows" => length(opt[:x]),
|
||||
"mesh/cols" => length(opt[:y]),
|
||||
)
|
||||
pgfx_add_series!(axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:contour}, axis, series_opt, series, series_func, opt)
|
||||
push!(axis.options, "view" => "{0}{90}")
|
||||
if isfilledcontour(series)
|
||||
pgfx_add_series!(Val(:filledcontour), axis, series_opt, series, series_func, opt)
|
||||
return nothing
|
||||
end
|
||||
pgfx_add_series!(Val(:contour3d), axis, series_opt, series, series_func, opt)
|
||||
return nothing
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:filledcontour}, axis, series_opt, series, series_func, opt)
|
||||
push!(
|
||||
series_opt,
|
||||
"contour filled" => PGFPlotsX.Options(), # labels not supported
|
||||
"patch type" => "bilinear",
|
||||
"shader" => "flat",
|
||||
)
|
||||
if opt[:levels] isa Number
|
||||
push!(series_opt["contour filled"], "number" => opt[:levels])
|
||||
elseif opt[:levels] isa AVec
|
||||
push!(series_opt["contour filled"], "levels" => opt[:levels])
|
||||
end
|
||||
pgfx_add_series!(axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:contour3d}, axis, series_opt, series, series_func, opt)
|
||||
push!(
|
||||
series_opt,
|
||||
"contour prepared" => PGFPlotsX.Options("labels" => opt[:contour_labels]),
|
||||
)
|
||||
args = pgfx_series_arguments(series, opt)
|
||||
series_plot = series_func(series_opt, PGFPlotsX.Table(Contour.contours(args..., opt[:levels])))
|
||||
push!(axis, series_plot)
|
||||
pgfx_add_legend!(axis, series, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:quiver}, axis, series_opt, series, series_func, opt)
|
||||
if opt[:quiver] !== nothing
|
||||
push!(
|
||||
series_opt,
|
||||
"quiver" => PGFPlotsX.Options(
|
||||
"u" => "\\thisrow{u}",
|
||||
"v" => "\\thisrow{v}",
|
||||
pgfx_arrow(opt[:arrow]) => nothing,
|
||||
),
|
||||
)
|
||||
x = opt[:x]
|
||||
y = opt[:y]
|
||||
table = PGFPlotsX.Table([
|
||||
:x => x,
|
||||
:y => y,
|
||||
:u => opt[:quiver][1],
|
||||
:v => opt[:quiver][2],
|
||||
])
|
||||
end
|
||||
series_plot = series_func(series_opt, table)
|
||||
push!(axis, series_plot)
|
||||
pgfx_add_legend!(axis, series, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:shape}, axis, series_opt, series, series_func, opt)
|
||||
push!(series_opt, "area legend" => nothing)
|
||||
series_opt = merge(series_opt, pgfx_fillstyle(opt))
|
||||
pgfx_add_series!(Val(:path), axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:steppre}, axis, series_opt, series, series_func, opt)
|
||||
push!(series_opt, "const plot mark right" => nothing)
|
||||
pgfx_add_series!(Val(:path), axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:stepmid}, axis, series_opt, series, series_func, opt)
|
||||
push!(series_opt, "const plot mark mid" => nothing)
|
||||
pgfx_add_series!(Val(:path), axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:steppost}, axis, series_opt, series, series_func, opt)
|
||||
push!(series_opt, "const plot" => nothing)
|
||||
pgfx_add_series!(Val(:path), axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:ysticks}, axis, series_opt, series, series_func, opt)
|
||||
push!(series_opt, "ycomb" => nothing)
|
||||
pgfx_add_series!(Val(:path), axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_series!(::Val{:xsticks}, axis, series_opt, series, series_func, opt)
|
||||
push!(series_opt, "xcomb" => nothing)
|
||||
pgfx_add_series!(Val(:path), axis, series_opt, series, series_func, opt)
|
||||
end
|
||||
|
||||
function pgfx_add_legend!(axis, series, opt, i = 1)
|
||||
if series[:subplot][:legend] != :none
|
||||
leg_entry = if opt[:label] isa AVec
|
||||
get(opt[:label], i, "")
|
||||
elseif opt[:label] isa AbstractString
|
||||
if i == 1
|
||||
get(opt, :label, "")
|
||||
else
|
||||
""
|
||||
end
|
||||
else
|
||||
throw(ArgumentError("Malformed label. label = $(opt[:label])"))
|
||||
end
|
||||
if leg_entry == "" || !pgfx_should_add_to_legend(series)
|
||||
push!(axis.contents[end].options, "forget plot" => nothing)
|
||||
else
|
||||
leg_opt = PGFPlotsX.Options()
|
||||
legend = PGFPlotsX.LegendEntry(leg_opt, leg_entry, false)
|
||||
push!(axis, legend)
|
||||
end
|
||||
end
|
||||
return nothing
|
||||
end
|
||||
|
||||
pgfx_series_arguments(series, opt, range) = (arg[range] for arg in pgfx_series_arguments(series, opt))
|
||||
function pgfx_series_arguments(series, opt)
|
||||
@inline function pgfx_series_coordinates!(sp, series, segment_opt, opt, rng)
|
||||
st = series[:seriestype]
|
||||
return if st in (:contour, :contour3d)
|
||||
# function args
|
||||
args = if st in (:contour, :contour3d)
|
||||
opt[:x], opt[:y], Array(opt[:z])'
|
||||
elseif st in (:heatmap, :surface, :wireframe)
|
||||
surface_to_vecs(opt[:x], opt[:y], opt[:z])
|
||||
@@ -599,12 +456,146 @@ function pgfx_series_arguments(series, opt)
|
||||
straightline_data(series)
|
||||
elseif st == :shape
|
||||
shape_data(series)
|
||||
elseif ispolar(series)
|
||||
elseif ispolar(sp)
|
||||
theta, r = opt[:x], opt[:y]
|
||||
rad2deg.(theta), r
|
||||
else
|
||||
opt[:x], opt[:y]
|
||||
end
|
||||
seg_args = if st in (:contour, :contour3d)
|
||||
args
|
||||
else
|
||||
(arg[rng] for arg in args)
|
||||
end
|
||||
if opt[:quiver] !== nothing
|
||||
push!(
|
||||
segment_opt,
|
||||
"quiver" => PGFPlotsX.Options(
|
||||
"u" => "\\thisrow{u}",
|
||||
"v" => "\\thisrow{v}",
|
||||
pgfx_arrow(opt[:arrow]) => nothing,
|
||||
),
|
||||
)
|
||||
x, y = collect(seg_args)
|
||||
return PGFPlotsX.Table([
|
||||
:x => x,
|
||||
:y => y,
|
||||
:u => opt[:quiver][1],
|
||||
:v => opt[:quiver][2],
|
||||
])
|
||||
else
|
||||
if isfilledcontour(series)
|
||||
st = :filledcontour
|
||||
end
|
||||
pgfx_series_coordinates!(Val(st), segment_opt, opt, seg_args)
|
||||
end
|
||||
end
|
||||
function pgfx_series_coordinates!(
|
||||
st_val::Union{Val{:path},Val{:path3d},Val{:straightline}},
|
||||
segment_opt,
|
||||
opt,
|
||||
args,
|
||||
)
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(
|
||||
st_val::Union{Val{:scatter},Val{:scatter3d}},
|
||||
segment_opt,
|
||||
opt,
|
||||
args,
|
||||
)
|
||||
push!(segment_opt, "only marks" => nothing)
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(st_val::Val{:heatmap}, segment_opt, opt, args)
|
||||
push!(
|
||||
segment_opt,
|
||||
"matrix plot*" => nothing,
|
||||
"mesh/rows" => length(opt[:x]),
|
||||
"mesh/cols" => length(opt[:y]),
|
||||
)
|
||||
return PGFPlotsX.Table(args...)
|
||||
end
|
||||
|
||||
function pgfx_series_coordinates!(st_val::Val{:steppre}, segment_opt, opt, args)
|
||||
push!(segment_opt, "const plot mark right" => nothing)
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(st_val::Val{:stepmid}, segment_opt, opt, args)
|
||||
push!(segment_opt, "const plot mark mid" => nothing)
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(st_val::Val{:steppost}, segment_opt, opt, args)
|
||||
push!(segment_opt, "const plot" => nothing)
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(
|
||||
st_val::Union{Val{:ysticks},Val{:sticks}},
|
||||
segment_opt,
|
||||
opt,
|
||||
args,
|
||||
)
|
||||
push!(segment_opt, "ycomb" => nothing)
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(st_val::Val{:xsticks}, segment_opt, opt, args)
|
||||
push!(segment_opt, "xcomb" => nothing)
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(st_val::Val{:surface}, segment_opt, opt, args)
|
||||
push!(
|
||||
segment_opt,
|
||||
"surf" => nothing,
|
||||
"mesh/rows" => length(opt[:x]),
|
||||
"mesh/cols" => length(opt[:y]),
|
||||
"z buffer" => "sort",
|
||||
)
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(st_val::Val{:volume}, segment_opt, opt, args)
|
||||
push!(segment_opt, "patch" => nothing)
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(st_val::Val{:wireframe}, segment_opt, opt, args)
|
||||
push!(segment_opt, "mesh" => nothing, "mesh/rows" => length(opt[:x]))
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(st_val::Val{:shape}, segment_opt, opt, args)
|
||||
push!(segment_opt, "area legend" => nothing)
|
||||
return PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
function pgfx_series_coordinates!(
|
||||
st_val::Union{Val{:contour},Val{:contour3d}},
|
||||
segment_opt,
|
||||
opt,
|
||||
args,
|
||||
)
|
||||
push!(
|
||||
segment_opt,
|
||||
"contour prepared" => PGFPlotsX.Options("labels" => opt[:contour_labels]),
|
||||
)
|
||||
return PGFPlotsX.Table(Contour.contours(args..., opt[:levels]))
|
||||
end
|
||||
function pgfx_series_coordinates!(
|
||||
st_val::Val{:filledcontour},
|
||||
segment_opt,
|
||||
opt,
|
||||
args,
|
||||
)
|
||||
xs, ys, zs = collect(args)
|
||||
push!(
|
||||
segment_opt,
|
||||
"contour filled" => PGFPlotsX.Options(), # labels not supported
|
||||
"patch type" => "bilinear",
|
||||
"shader" => "flat",
|
||||
)
|
||||
if opt[:levels] isa Number
|
||||
push!(segment_opt["contour filled"], "number" => opt[:levels])
|
||||
elseif opt[:levels] isa AVec
|
||||
push!(segment_opt["contour filled"], "levels" => opt[:levels])
|
||||
end
|
||||
|
||||
PGFPlotsX.Coordinates(args...)
|
||||
end
|
||||
##
|
||||
pgfx_get_linestyle(k) = get(
|
||||
@@ -837,12 +828,9 @@ function pgfx_marker(plotattributes, i = 1)
|
||||
pgfx_thickness_scaling(plotattributes) *
|
||||
0.75 *
|
||||
_cycle(plotattributes[:markersize], i)
|
||||
mark_freq = !any(isnan, plotattributes[:y]) && plotattributes[:markershape] isa AVec ?
|
||||
length(plotattributes[:markershape]) : 1
|
||||
return PGFPlotsX.Options(
|
||||
"mark" => shape isa Shape ? "PlotsShape$i" : pgfx_get_marker(shape),
|
||||
"mark size" => "$mark_size pt",
|
||||
"mark repeat" => mark_freq,
|
||||
"mark options" => PGFPlotsX.Options(
|
||||
"color" => cstr_stroke,
|
||||
"draw opacity" => a_stroke,
|
||||
@@ -972,7 +960,7 @@ function pgfx_fillrange_args(fillrange, x, y, z)
|
||||
x_fill = [x; x[n:-1:1]; x[1]]
|
||||
y_fill = [y; y[n:-1:1]; x[1]]
|
||||
z_fill = [z; _cycle(fillrange, n:-1:1); z[1]]
|
||||
return PGFPlotsX.Coordinates(x_fill, y_fill, z_fill)
|
||||
return PGFPlotsX.Coordiantes(x_fill, y_fill, z_fill)
|
||||
end
|
||||
|
||||
function pgfx_sanitize_string(p::PlotText)
|
||||
|
||||
+8
-22
@@ -19,16 +19,6 @@ using UUIDs
|
||||
|
||||
# ----------------------------------------------------------------
|
||||
|
||||
function labelfunc(scale::Symbol, backend::PlotlyBackend)
|
||||
texfunc = labelfunc_tex(scale)
|
||||
function (x)
|
||||
tex_x = texfunc(x)
|
||||
sup_x = replace( tex_x, r"\^{(.*)}"=>s"<sup>\1</sup>" )
|
||||
# replace dash with \minus (U+2212)
|
||||
replace(sup_x, "-" => "−")
|
||||
end
|
||||
end
|
||||
|
||||
function plotly_font(font::Font, color = font.color)
|
||||
KW(
|
||||
:family => font.family,
|
||||
@@ -346,7 +336,7 @@ function plotly_legend_pos(pos::Symbol)
|
||||
ybot = 0.07
|
||||
ytop = 1.0
|
||||
xcenter = 0.55
|
||||
ycenter = 0.52
|
||||
ycenter = 0.52
|
||||
center = 0.5
|
||||
youtertop = 1.1
|
||||
youterbot = -0.15
|
||||
@@ -361,9 +351,9 @@ function plotly_legend_pos(pos::Symbol)
|
||||
bottomright = (coords = [1.0, ybot], xanchor = "right", yanchor = "bottom"),
|
||||
topright = (coords = [1.0, 1.0], xanchor = "right", yanchor = "top"),
|
||||
topleft = (coords = [xleft, 1.0], xanchor = "left", yanchor = "top"),
|
||||
outertop =(coords = [center, youtertop ], xanchor = "upper", yanchor = "middle"),
|
||||
outerbottom =(coords = [center, youterbot], xanchor = "lower", yanchor = "middle"),
|
||||
outerleft =(coords = [xouterleft, center], xanchor = "left", yanchor = "top"),
|
||||
outertop =(coords = [center, youtertop ], xanchor = "upper", yanchor = "middle"),
|
||||
outerbottom =(coords = [center, youterbot], xanchor = "lower", yanchor = "middle"),
|
||||
outerleft =(coords = [xouterleft, center], xanchor = "left", yanchor = "top"),
|
||||
outerright =(coords = [xouterright, center], xanchor = "right", yanchor = "top"),
|
||||
outertopleft =(coords = [xouterleft, ytop], xanchor = "upper", yanchor = "left"),
|
||||
outertopright = (coords = [xouterright, ytop], xanchor = "upper", yanchor = "right"),
|
||||
@@ -694,11 +684,9 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
|
||||
hasfillrange = st in (:path, :scatter, :scattergl, :straightline) &&
|
||||
(isa(series[:fillrange], AbstractVector) || isa(series[:fillrange], Tuple))
|
||||
|
||||
segments = iter_segments(series, st)
|
||||
segments = iter_segments(series)
|
||||
plotattributes_outs = fill(KW(), (hasfillrange ? 2 : 1 ) * length(segments))
|
||||
|
||||
needs_scatter_fix = !isscatter && hasmarker && !any(isnan,y)
|
||||
|
||||
for (i,rng) in enumerate(segments)
|
||||
plotattributes_out = deepcopy(plotattributes_base)
|
||||
plotattributes_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
|
||||
@@ -735,15 +723,13 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
|
||||
|
||||
# add "marker"
|
||||
if hasmarker
|
||||
mcolor = rgba_string(plot_color(get_markercolor(series, clims, i), get_markeralpha(series, i)))
|
||||
lcolor = rgba_string(plot_color(get_markerstrokecolor(series, i), get_markerstrokealpha(series, i)))
|
||||
plotattributes_out[:marker] = KW(
|
||||
:symbol => get_plotly_marker(_cycle(series[:markershape], i), string(_cycle(series[:markershape], i))),
|
||||
# :opacity => needs_scatter_fix ? [1, 0] : 1,
|
||||
# :opacity => series[:markeralpha],
|
||||
:size => 2 * _cycle(series[:markersize], i),
|
||||
:color => needs_scatter_fix ? [mcolor, "rgba(0, 0, 0, 0.000)"] : mcolor,
|
||||
:color => rgba_string(plot_color(get_markercolor(series, clims, i), get_markeralpha(series, i))),
|
||||
:line => KW(
|
||||
:color => needs_scatter_fix ? [lcolor, "rgba(0, 0, 0, 0.000)"] : lcolor,
|
||||
:color => rgba_string(plot_color(get_markerstrokecolor(series, i), get_markerstrokealpha(series, i))),
|
||||
:width => _cycle(series[:markerstrokewidth], i),
|
||||
),
|
||||
)
|
||||
|
||||
+130
-15
@@ -176,7 +176,15 @@ function add_pyfixedformatter(cbar, vals::AVec)
|
||||
end
|
||||
|
||||
function labelfunc(scale::Symbol, backend::PyPlotBackend)
|
||||
PyPlot.LaTeXStrings.latexstring ∘ labelfunc_tex(scale)
|
||||
if scale == :log10
|
||||
x -> PyPlot.LaTeXStrings.latexstring("10^{$x}")
|
||||
elseif scale == :log2
|
||||
x -> PyPlot.LaTeXStrings.latexstring("2^{$x}")
|
||||
elseif scale == :ln
|
||||
x -> PyPlot.LaTeXStrings.latexstring("e^{$x}")
|
||||
else
|
||||
x -> PyPlot.LaTeXStrings.latexstring(convert_sci_unicode(x))
|
||||
end
|
||||
end
|
||||
|
||||
function py_mask_nans(z)
|
||||
@@ -398,6 +406,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
|
||||
# line plot
|
||||
if st in (:path, :path3d, :steppre, :steppost, :straightline)
|
||||
if maximum(series[:linewidth]) > 0
|
||||
segments = iter_segments(series)
|
||||
# TODO: check LineCollection alternative for speed
|
||||
# if length(segments) > 1 && (any(typeof(series[attr]) <: AbstractVector for attr in (:fillcolor, :fillalpha)) || series[:fill_z] !== nothing) && !(typeof(series[:linestyle]) <: AbstractVector)
|
||||
# # multicolored line segments
|
||||
@@ -428,7 +437,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
|
||||
# end
|
||||
# push!(handles, handle)
|
||||
# else
|
||||
for (i, rng) in enumerate(iter_segments(series, st))
|
||||
for (i, rng) in enumerate(iter_segments(series))
|
||||
handle = ax."plot"((arg[rng] for arg in xyargs)...;
|
||||
label = i == 1 ? series[:label] : "",
|
||||
zorder = series[:series_plotindex],
|
||||
@@ -471,24 +480,130 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
|
||||
end
|
||||
|
||||
# add markers?
|
||||
if series[:markershape] != :none && st in (
|
||||
:path, :scatter, :path3d, :scatter3d, :steppre, :steppost, :bar
|
||||
)
|
||||
for (i, rng) in enumerate(iter_segments(series, :scatter))
|
||||
xyargs = if st == :bar && !isvertical(series)
|
||||
y[rng], x[rng]
|
||||
else
|
||||
x[rng], y[rng]
|
||||
if series[:markershape] != :none && st in (:path, :scatter, :path3d,
|
||||
:scatter3d, :steppre, :steppost,
|
||||
:bar)
|
||||
markercolor = if any(typeof(series[arg]) <: AVec for arg in (:markercolor, :markeralpha)) || series[:marker_z] !== nothing
|
||||
# py_color(plot_color.(get_markercolor.(series, clims, eachindex(x)), get_markeralpha.(series, eachindex(x))))
|
||||
[py_color(plot_color(get_markercolor(series, clims, i), get_markeralpha(series, i))) for i in eachindex(x)]
|
||||
else
|
||||
py_color(plot_color(series[:markercolor], series[:markeralpha]))
|
||||
end
|
||||
extrakw[:c] = if markercolor isa Array
|
||||
permutedims(hcat([[m...] for m in markercolor]...),[2,1])
|
||||
elseif markercolor isa Tuple
|
||||
reshape([markercolor...], 1, length(markercolor))
|
||||
else
|
||||
error("This case is not handled. Please file an issue.")
|
||||
end
|
||||
xyargs = if st == :bar && !isvertical(series)
|
||||
(y, x)
|
||||
else
|
||||
xyargs
|
||||
end
|
||||
|
||||
if isa(series[:markershape], AbstractVector{Shape})
|
||||
# this section will create one scatter per data point to accommodate the
|
||||
# vector of shapes
|
||||
handle = []
|
||||
x,y = xyargs
|
||||
shapes = series[:markershape]
|
||||
msc = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series))
|
||||
lw = py_thickness_scale(plt, series[:markerstrokewidth])
|
||||
for i=eachindex(y)
|
||||
if series[:marker_z] !== nothing
|
||||
extrakw[:c] = [py_color(get_markercolor(series, i), get_markercoloralpha(series, i))]
|
||||
end
|
||||
|
||||
push!(handle, ax."scatter"(_cycle(x,i), _cycle(y,i);
|
||||
label = series[:label],
|
||||
zorder = series[:series_plotindex] + 0.5,
|
||||
marker = py_marker(_cycle(shapes,i)),
|
||||
s = py_thickness_scale(plt, _cycle(series[:markersize],i)).^ 2,
|
||||
facecolors = py_color(get_markercolor(series, i), get_markercoloralpha(series, i)),
|
||||
edgecolors = msc,
|
||||
linewidths = lw,
|
||||
extrakw...
|
||||
))
|
||||
end
|
||||
push!(handles, handle)
|
||||
elseif isa(series[:markershape], AbstractVector{Symbol})
|
||||
handle = []
|
||||
x,y = xyargs
|
||||
shapes = series[:markershape]
|
||||
|
||||
prev_marker = py_marker(_cycle(shapes,1))
|
||||
|
||||
cur_x_list = []
|
||||
cur_y_list = []
|
||||
|
||||
cur_color_list = []
|
||||
cur_scale_list = []
|
||||
|
||||
delete!(extrakw, :c)
|
||||
|
||||
for i=eachindex(y)
|
||||
cur_marker = py_marker(_cycle(shapes,i))
|
||||
|
||||
if ( cur_marker == prev_marker )
|
||||
push!(cur_x_list, _cycle(x,i))
|
||||
push!(cur_y_list, _cycle(y,i))
|
||||
|
||||
push!(cur_color_list, _cycle(markercolor, i))
|
||||
push!(cur_scale_list, py_thickness_scale(plt, _cycle(series[:markersize],i)).^ 2)
|
||||
|
||||
continue
|
||||
end
|
||||
|
||||
push!(handle, ax."scatter"(cur_x_list, cur_y_list;
|
||||
label = series[:label],
|
||||
zorder = series[:series_plotindex] + 0.5,
|
||||
marker = prev_marker,
|
||||
s = cur_scale_list,
|
||||
edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
|
||||
linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
|
||||
facecolors = cur_color_list,
|
||||
extrakw...
|
||||
))
|
||||
|
||||
cur_x_list = [_cycle(x,i)]
|
||||
cur_y_list = [_cycle(y,i)]
|
||||
|
||||
cur_color_list = [_cycle(markercolor, i)]
|
||||
cur_scale_list = [py_thickness_scale(plt, _cycle(series[:markersize],i)) .^ 2]
|
||||
|
||||
prev_marker = cur_marker
|
||||
end
|
||||
|
||||
if !isempty(cur_color_list)
|
||||
push!(handle, ax."scatter"(cur_x_list, cur_y_list;
|
||||
label = series[:label],
|
||||
zorder = series[:series_plotindex] + 0.5,
|
||||
marker = prev_marker,
|
||||
s = cur_scale_list,
|
||||
edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
|
||||
linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
|
||||
facecolors = cur_color_list,
|
||||
extrakw...
|
||||
))
|
||||
end
|
||||
|
||||
push!(handles, handle)
|
||||
else
|
||||
# do a normal scatter plot
|
||||
|
||||
# Add depthshade option for 3d plots
|
||||
if RecipesPipeline.is3d(sp)
|
||||
extrakw[:depthshade] = get(series[:extra_kwargs], :depthshade, false)
|
||||
end
|
||||
|
||||
handle = ax."scatter"(xyargs...;
|
||||
label = series[:label],
|
||||
zorder = series[:series_plotindex] + 0.5,
|
||||
marker = py_marker(_cycle(series[:markershape], i)),
|
||||
s = py_thickness_scale(plt, _cycle(series[:markersize], i)).^ 2,
|
||||
facecolors = py_color(get_markercolor(series, i), get_markeralpha(series, i)),
|
||||
edgecolors = py_color(get_markerstrokecolor(series, i), get_markerstrokealpha(series, i)),
|
||||
linewidths = py_thickness_scale(plt, get_markerstrokewidth(series, i)),
|
||||
marker = py_marker(series[:markershape]),
|
||||
s = py_thickness_scale(plt, series[:markersize]) .^2,
|
||||
edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
|
||||
linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
|
||||
extrakw...
|
||||
)
|
||||
push!(handles, handle)
|
||||
|
||||
+65
-81
@@ -9,7 +9,7 @@ end
|
||||
|
||||
# the _examples we'll run for each
|
||||
const _examples = PlotExample[
|
||||
PlotExample( # 1
|
||||
PlotExample(
|
||||
"Lines",
|
||||
"A simple line plot of the columns.",
|
||||
[:(
|
||||
@@ -18,7 +18,7 @@ const _examples = PlotExample[
|
||||
end
|
||||
)],
|
||||
),
|
||||
PlotExample( # 2
|
||||
PlotExample(
|
||||
"Functions, adding data, and animations",
|
||||
"""
|
||||
Plot multiple functions. You can also put the function first, or use the form `plot(f,
|
||||
@@ -30,16 +30,16 @@ const _examples = PlotExample[
|
||||
""",
|
||||
[:(
|
||||
begin
|
||||
p = plot([sin, cos], zeros(0), leg = false, xlims = (0, 2π), ylims = (-1, 1))
|
||||
p = plot([sin, cos], zeros(0), leg = false)
|
||||
anim = Animation()
|
||||
for x in range(0, stop = 2π, length = 20)
|
||||
for x in range(0, stop = 10π, length = 100)
|
||||
push!(p, x, Float64[sin(x), cos(x)])
|
||||
frame(anim)
|
||||
end
|
||||
end
|
||||
)],
|
||||
),
|
||||
PlotExample( # 3
|
||||
PlotExample(
|
||||
"Parametric plots",
|
||||
"Plot function pair (x(u), y(u)).",
|
||||
[
|
||||
@@ -58,7 +58,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 4
|
||||
PlotExample(
|
||||
"Colors",
|
||||
"""
|
||||
Access predefined palettes (or build your own with the `colorscheme` method).
|
||||
@@ -89,7 +89,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 5
|
||||
PlotExample(
|
||||
"Global",
|
||||
"""
|
||||
Change the guides/background/limits/ticks. Convenience args `xaxis` and `yaxis` allow
|
||||
@@ -121,7 +121,13 @@ const _examples = PlotExample[
|
||||
],
|
||||
),
|
||||
|
||||
PlotExample( # 6
|
||||
# PlotExample("Two-axis",
|
||||
# "Use the `axis` arguments.",
|
||||
# [
|
||||
# :(plot(Vector[randn(100), randn(100)*100], axis = [:l :r], ylabel="LEFT", yrightlabel="RIGHT", xlabel="X", title="TITLE"))
|
||||
# ]),
|
||||
|
||||
PlotExample(
|
||||
"Images",
|
||||
"Plot an image. y-axis is set to flipped",
|
||||
[
|
||||
@@ -136,7 +142,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 7
|
||||
PlotExample(
|
||||
"Arguments",
|
||||
"""
|
||||
Plot multiple series with different numbers of points. Mix arguments that apply to all
|
||||
@@ -160,7 +166,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 8
|
||||
PlotExample(
|
||||
"Build plot in pieces",
|
||||
"Start with a base plot...",
|
||||
[:(
|
||||
@@ -169,7 +175,7 @@ const _examples = PlotExample[
|
||||
end
|
||||
)],
|
||||
),
|
||||
PlotExample( # 9
|
||||
PlotExample(
|
||||
"",
|
||||
"and add to it later.",
|
||||
[:(
|
||||
@@ -178,7 +184,7 @@ const _examples = PlotExample[
|
||||
end
|
||||
)],
|
||||
),
|
||||
PlotExample( # 10
|
||||
PlotExample(
|
||||
"Histogram2D",
|
||||
"",
|
||||
[:(
|
||||
@@ -187,7 +193,7 @@ const _examples = PlotExample[
|
||||
end
|
||||
)],
|
||||
),
|
||||
PlotExample( # 11
|
||||
PlotExample(
|
||||
"Line types",
|
||||
"",
|
||||
[
|
||||
@@ -208,7 +214,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 12
|
||||
PlotExample(
|
||||
"Line styles",
|
||||
"",
|
||||
[
|
||||
@@ -231,7 +237,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 13
|
||||
PlotExample(
|
||||
"Marker types",
|
||||
"",
|
||||
[
|
||||
@@ -258,7 +264,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 14
|
||||
PlotExample(
|
||||
"Bar",
|
||||
"`x` is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)",
|
||||
[:(
|
||||
@@ -267,7 +273,7 @@ const _examples = PlotExample[
|
||||
end
|
||||
)],
|
||||
),
|
||||
PlotExample( # 15
|
||||
PlotExample(
|
||||
"Histogram",
|
||||
"",
|
||||
[
|
||||
@@ -282,7 +288,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 16
|
||||
PlotExample(
|
||||
"Subplots",
|
||||
"""
|
||||
Use the `layout` keyword, and optionally the convenient `@layout` macro to generate
|
||||
@@ -304,7 +310,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 17
|
||||
PlotExample(
|
||||
"Adding to subplots",
|
||||
"""
|
||||
Note here the automatic grid layout, as well as the order in which new series are added
|
||||
@@ -323,20 +329,14 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 18
|
||||
"",
|
||||
"",
|
||||
[
|
||||
:(
|
||||
begin
|
||||
using Random
|
||||
Random.seed!(111)
|
||||
plot!(Plots.fakedata(100, 10))
|
||||
end
|
||||
)
|
||||
]
|
||||
),
|
||||
PlotExample( # 19
|
||||
PlotExample("", "", [:(
|
||||
begin
|
||||
using Random
|
||||
Random.seed!(111)
|
||||
plot!(Plots.fakedata(100, 10))
|
||||
end
|
||||
)]),
|
||||
PlotExample(
|
||||
"Open/High/Low/Close",
|
||||
"""
|
||||
Create an OHLC chart. Pass in a list of (open,high,low,close) tuples as your `y`
|
||||
@@ -365,7 +365,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 20
|
||||
PlotExample(
|
||||
"Annotations",
|
||||
"""
|
||||
The `annotations` keyword is used for text annotations in data-coordinates. Pass in a
|
||||
@@ -408,7 +408,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 21
|
||||
PlotExample(
|
||||
"Custom Markers",
|
||||
"""A `Plots.Shape` is a light wrapper around vertices of a polygon. For supported
|
||||
backends, pass arbitrary polygons as the marker shapes. Note: The center is (0,0) and
|
||||
@@ -454,7 +454,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 22
|
||||
PlotExample(
|
||||
"Contours",
|
||||
"""
|
||||
Any value for fill works here. We first build a filled contour from a function, then an
|
||||
@@ -474,7 +474,7 @@ const _examples = PlotExample[
|
||||
end
|
||||
)],
|
||||
),
|
||||
PlotExample( # 23
|
||||
PlotExample(
|
||||
"Pie",
|
||||
"",
|
||||
[:(
|
||||
@@ -485,7 +485,7 @@ const _examples = PlotExample[
|
||||
end
|
||||
)],
|
||||
),
|
||||
PlotExample( # 24
|
||||
PlotExample(
|
||||
"3D",
|
||||
"",
|
||||
[
|
||||
@@ -511,7 +511,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 25
|
||||
PlotExample(
|
||||
"DataFrames",
|
||||
"Plot using DataFrame column symbols.",
|
||||
[
|
||||
@@ -534,7 +534,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 26
|
||||
PlotExample(
|
||||
"Groups and Subplots",
|
||||
"",
|
||||
[
|
||||
@@ -552,7 +552,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 27
|
||||
PlotExample(
|
||||
"Polar Plots",
|
||||
"",
|
||||
[:(
|
||||
@@ -563,7 +563,7 @@ const _examples = PlotExample[
|
||||
end
|
||||
)],
|
||||
),
|
||||
PlotExample( # 28
|
||||
PlotExample(
|
||||
"Heatmap, categorical axes, and aspect_ratio",
|
||||
"",
|
||||
[:(
|
||||
@@ -575,7 +575,7 @@ const _examples = PlotExample[
|
||||
end
|
||||
)],
|
||||
),
|
||||
PlotExample( # 29
|
||||
PlotExample(
|
||||
"Layouts, margins, label rotation, title location",
|
||||
"",
|
||||
[
|
||||
@@ -595,7 +595,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 30
|
||||
PlotExample(
|
||||
"Boxplot and Violin series recipes",
|
||||
"",
|
||||
[
|
||||
@@ -620,7 +620,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 31
|
||||
PlotExample(
|
||||
"Animation with subplots",
|
||||
"The `layout` macro can be used to create an animation with subplots.",
|
||||
[
|
||||
@@ -628,15 +628,14 @@ const _examples = PlotExample[
|
||||
begin
|
||||
l = @layout([[a; b] c])
|
||||
p = plot(
|
||||
plot([sin, cos], 1, ylims = (-1, 1), leg = false),
|
||||
scatter([atan, cos], 1, ylims = (-1, 1.5), leg = false),
|
||||
plot(log, 1, ylims = (0, 2), leg = false),
|
||||
plot([sin, cos], 1, leg = false),
|
||||
scatter([atan, cos], 1, leg = false),
|
||||
plot(log, 1, xlims = (1, 10π), ylims = (0, 5), leg = false),
|
||||
layout = l,
|
||||
xlims = (1, 2π),
|
||||
)
|
||||
|
||||
anim = Animation()
|
||||
for x in range(1, stop = 2π, length = 20)
|
||||
for x in range(1, stop = 10π, length = 100)
|
||||
plot(push!(
|
||||
p,
|
||||
x,
|
||||
@@ -648,7 +647,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 32
|
||||
PlotExample(
|
||||
"Spy",
|
||||
"""
|
||||
For a matrix `mat` with unique nonzeros `spy(mat)` returns a colorless plot. If `mat` has
|
||||
@@ -682,7 +681,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 33
|
||||
PlotExample(
|
||||
"Magic grid argument",
|
||||
"""
|
||||
The grid lines can be modified individually for each axis with the magic `grid` argument.
|
||||
@@ -712,7 +711,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 34
|
||||
PlotExample(
|
||||
"Framestyle",
|
||||
"""
|
||||
The style of the frame/axes of a (sub)plot can be changed with the `framestyle`
|
||||
@@ -736,7 +735,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 35
|
||||
PlotExample(
|
||||
"Lines and markers with varying colors",
|
||||
"""
|
||||
You can use the `line_z` and `marker_z` properties to associate a color with
|
||||
@@ -762,7 +761,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 36
|
||||
PlotExample(
|
||||
"Portfolio Composition maps",
|
||||
"""
|
||||
see: http://stackoverflow.com/a/37732384/5075246
|
||||
@@ -788,7 +787,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 37
|
||||
PlotExample(
|
||||
"Ribbons",
|
||||
"""
|
||||
Ribbons can be added to lines via the `ribbon` keyword;
|
||||
@@ -811,7 +810,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 38
|
||||
PlotExample(
|
||||
"Histogram2D (complex values)",
|
||||
"",
|
||||
[
|
||||
@@ -830,7 +829,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 39
|
||||
PlotExample(
|
||||
"Unconnected lines using `missing` or `NaN`",
|
||||
"""
|
||||
Missing values and non-finite values, including `NaN`, are not plotted.
|
||||
@@ -854,7 +853,7 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 40
|
||||
PlotExample(
|
||||
"Lens",
|
||||
"A lens lets you easily magnify a region of a plot. x and y coordinates refer to the to be magnified region and the via the `inset` keyword the subplot index and the bounding box (in relative coordinates) of the inset plot with the magnified plot can be specified. Additional attributes count for the inset plot.",
|
||||
[
|
||||
@@ -876,7 +875,7 @@ const _examples = PlotExample[
|
||||
end,
|
||||
],
|
||||
),
|
||||
PlotExample( # 41
|
||||
PlotExample(
|
||||
"Array Types",
|
||||
"Plots supports different `Array` types that follow the `AbstractArray` interface, like `StaticArrays` and `OffsetArrays.`",
|
||||
[
|
||||
@@ -891,7 +890,7 @@ const _examples = PlotExample[
|
||||
end,
|
||||
],
|
||||
),
|
||||
PlotExample( # 42
|
||||
PlotExample(
|
||||
"Setting defaults and font arguments",
|
||||
"",
|
||||
[
|
||||
@@ -921,7 +920,7 @@ const _examples = PlotExample[
|
||||
end,
|
||||
],
|
||||
),
|
||||
PlotExample( # 43
|
||||
PlotExample(
|
||||
"Heatmap with DateTime axis",
|
||||
"",
|
||||
[
|
||||
@@ -936,7 +935,7 @@ const _examples = PlotExample[
|
||||
end,
|
||||
],
|
||||
),
|
||||
PlotExample( # 44
|
||||
PlotExample(
|
||||
"Linked axes",
|
||||
"",
|
||||
[
|
||||
@@ -948,7 +947,7 @@ const _examples = PlotExample[
|
||||
end,
|
||||
],
|
||||
),
|
||||
PlotExample( # 45
|
||||
PlotExample(
|
||||
"Error bars and array type recipes",
|
||||
"",
|
||||
[
|
||||
@@ -985,7 +984,7 @@ const _examples = PlotExample[
|
||||
end,
|
||||
],
|
||||
),
|
||||
PlotExample( # 46
|
||||
PlotExample(
|
||||
"Tuples and `Point`s as data",
|
||||
"",
|
||||
[quote
|
||||
@@ -996,7 +995,7 @@ const _examples = PlotExample[
|
||||
scatter!(Point2.(eachcol(rand(d,1000))), alpha=0.25)
|
||||
end]
|
||||
),
|
||||
PlotExample( # 47
|
||||
PlotExample(
|
||||
"Mesh3d",
|
||||
"""
|
||||
Allows to plot arbitrary 3d meshes. If only x,y,z are given the mesh is generated automatically.
|
||||
@@ -1025,21 +1024,6 @@ const _examples = PlotExample[
|
||||
),
|
||||
],
|
||||
),
|
||||
PlotExample( # 48
|
||||
"Vectors of markershapes and segments",
|
||||
"",
|
||||
[quote
|
||||
yv = ones(9)
|
||||
ys = [1; 1; NaN; ones(6)]
|
||||
plot(
|
||||
5 .- [yv 2ys 3yv 4ys],
|
||||
seriestype = [:path :path :scatter :scatter],
|
||||
markershape = [:utriangle, :rect],
|
||||
markersize = 8,
|
||||
color = [:red, :black],
|
||||
)
|
||||
end]
|
||||
),
|
||||
]
|
||||
|
||||
# Some constants for PlotDocs and PlotReferenceImages
|
||||
|
||||
+4
-1
@@ -194,9 +194,9 @@ function _display(plt::Plot)
|
||||
@warn("_display is not defined for this backend.")
|
||||
end
|
||||
|
||||
Base.show(io::IO, m::MIME"text/plain", plt::Plot) = show(io, plt)
|
||||
# for writing to io streams... first prepare, then callback
|
||||
for mime in (
|
||||
"text/plain",
|
||||
"text/html",
|
||||
"image/png",
|
||||
"image/eps",
|
||||
@@ -221,6 +221,9 @@ end
|
||||
Base.show(io::IO, m::MIME"application/prs.juno.plotpane+html", plt::Plot) =
|
||||
showjuno(io, MIME("text/html"), plt)
|
||||
|
||||
# default text/plain for all backends
|
||||
_show(io::IO, ::MIME{Symbol("text/plain")}, plt::Plot) = show(io, plt)
|
||||
|
||||
"Close all open gui windows of the current backend"
|
||||
closeall() = closeall(backend())
|
||||
|
||||
|
||||
@@ -55,17 +55,6 @@ end
|
||||
|
||||
|
||||
## Preprocessing attributes
|
||||
function RecipesPipeline.preprocess_axis_args!(plt::Plot, plotattributes, letter)
|
||||
# Fix letter for seriestypes that are x only but data gets passed as y
|
||||
if treats_y_as_x(get(plotattributes, :seriestype, :path))
|
||||
if get(plotattributes, :orientation, :vertical) == :vertical
|
||||
letter = :x
|
||||
end
|
||||
end
|
||||
|
||||
plotattributes[:letter] = letter
|
||||
RecipesPipeline.preprocess_axis_args!(plt, plotattributes)
|
||||
end
|
||||
|
||||
RecipesPipeline.preprocess_attributes!(plt::Plot, plotattributes) =
|
||||
RecipesPipeline.preprocess_attributes!(plotattributes) # in src/args.jl
|
||||
|
||||
@@ -21,6 +21,9 @@ else
|
||||
elseif v"1.5.0-DEV" <= VERSION <= v"1.5.9"
|
||||
include("../deps/SnoopCompile/precompile/linux/1.5/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
elseif v"1.6.0-DEV" <= VERSION <= v"1.6.9"
|
||||
include("../deps/SnoopCompile/precompile/linux/1.6/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
else
|
||||
include("../deps/SnoopCompile/precompile/linux/1.4/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
@@ -36,6 +39,9 @@ else
|
||||
elseif v"1.5.0-DEV" <= VERSION <= v"1.5.9"
|
||||
include("../deps/SnoopCompile/precompile/windows/1.5/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
elseif v"1.6.0-DEV" <= VERSION <= v"1.6.9"
|
||||
include("../deps/SnoopCompile/precompile/windows/1.6/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
else
|
||||
include("../deps/SnoopCompile/precompile/windows/1.4/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
@@ -51,6 +57,9 @@ else
|
||||
elseif v"1.5.0-DEV" <= VERSION <= v"1.5.9"
|
||||
include("../deps/SnoopCompile/precompile/apple/1.5/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
elseif v"1.6.0-DEV" <= VERSION <= v"1.6.9"
|
||||
include("../deps/SnoopCompile/precompile/apple/1.6/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
else
|
||||
include("../deps/SnoopCompile/precompile/apple/1.4/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
@@ -66,6 +75,9 @@ else
|
||||
elseif v"1.5.0-DEV" <= VERSION <= v"1.5.9"
|
||||
include("../deps/SnoopCompile/precompile/linux/1.5/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
elseif v"1.6.0-DEV" <= VERSION <= v"1.6.9"
|
||||
include("../deps/SnoopCompile/precompile/linux/1.6/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
else
|
||||
include("../deps/SnoopCompile/precompile/linux/1.4/precompile_Plots.jl")
|
||||
_precompile_()
|
||||
|
||||
+6
-5
@@ -124,8 +124,9 @@ end
|
||||
@recipe function f(::Type{Val{:vline}}, x, y, z)
|
||||
n = length(y)
|
||||
newx = vec(Float64[yi for i = 1:3, yi in y])
|
||||
newy = repeat(Float64[1, 2, NaN], n)
|
||||
x := newx
|
||||
y := repeat(Float64[1, 2, NaN], n)
|
||||
y := newy
|
||||
seriestype := :straightline
|
||||
()
|
||||
end
|
||||
@@ -133,7 +134,7 @@ end
|
||||
|
||||
@recipe function f(::Type{Val{:hspan}}, x, y, z)
|
||||
n = div(length(y), 2)
|
||||
newx = repeat([1, 2, 2, 1, NaN], outer = n)
|
||||
newx = repeat([-Inf, Inf, Inf, -Inf, NaN], outer = n)
|
||||
newy = vcat([[y[2i - 1], y[2i - 1], y[2i], y[2i], NaN] for i = 1:n]...)
|
||||
linewidth --> 0
|
||||
x := newx
|
||||
@@ -764,7 +765,7 @@ end
|
||||
|
||||
@recipe function f(::Type{Val{:barhist}}, x, y, z)
|
||||
h = _make_hist(
|
||||
tuple(y),
|
||||
(y,),
|
||||
plotattributes[:bins],
|
||||
normed = plotattributes[:normalize],
|
||||
weights = plotattributes[:weights],
|
||||
@@ -778,7 +779,7 @@ end
|
||||
|
||||
@recipe function f(::Type{Val{:stephist}}, x, y, z)
|
||||
h = _make_hist(
|
||||
tuple(y),
|
||||
(y,),
|
||||
plotattributes[:bins],
|
||||
normed = plotattributes[:normalize],
|
||||
weights = plotattributes[:weights],
|
||||
@@ -792,7 +793,7 @@ end
|
||||
|
||||
@recipe function f(::Type{Val{:scatterhist}}, x, y, z)
|
||||
h = _make_hist(
|
||||
tuple(y),
|
||||
(y,),
|
||||
plotattributes[:bins],
|
||||
normed = plotattributes[:normalize],
|
||||
weights = plotattributes[:weights],
|
||||
|
||||
+1
-1
@@ -69,7 +69,7 @@ Make a histogram bar plot. See `histogram`.
|
||||
|
||||
"""
|
||||
stephist(x)
|
||||
stephist!(x)
|
||||
stephist(x)
|
||||
|
||||
Make a histogram step plot (bin counts are represented using horizontal lines
|
||||
instead of bars). See `histogram`.
|
||||
|
||||
+10
-11
@@ -1,6 +1,4 @@
|
||||
function treats_y_as_x(seriestype)
|
||||
return seriestype in (:vline, :vspan, :histogram, :barhist, :stephist, :scatterhist)
|
||||
end
|
||||
|
||||
function replace_image_with_heatmap(z::Array{T}) where T<:Colorant
|
||||
n, m = size(z)
|
||||
colors = palette(vec(z))
|
||||
@@ -69,17 +67,19 @@ function iter_segments(args...)
|
||||
SegmentsIterator(tup, n1, n2)
|
||||
end
|
||||
|
||||
function iter_segments(series::Series, seriestype::Symbol = :path)
|
||||
function iter_segments(series::Series)
|
||||
x, y, z = series[:x], series[:y], series[:z]
|
||||
if x === nothing
|
||||
return UnitRange{Int}[]
|
||||
elseif has_attribute_segments(series)
|
||||
if any(isnan,y)
|
||||
return [iter_segments(y)...]
|
||||
elseif seriestype in (:scatter, :scatter3d)
|
||||
if series[:seriestype] in (:scatter, :scatter3d)
|
||||
return [[i] for i in eachindex(y)]
|
||||
else
|
||||
return [i:(i + 1) for i in firstindex(y):lastindex(y)-1]
|
||||
if any(isnan,y)
|
||||
return [iter_segments(y)...]
|
||||
else
|
||||
return [i:(i + 1) for i in firstindex(y):lastindex(y)-1]
|
||||
end
|
||||
end
|
||||
else
|
||||
segs = UnitRange{Int}[]
|
||||
@@ -617,7 +617,6 @@ function has_attribute_segments(series::Series)
|
||||
:markerstrokecolor,
|
||||
:markerstrokealpha,
|
||||
:markerstrokewidth,
|
||||
:markershape,
|
||||
]
|
||||
) || any(
|
||||
typeof(series[attr]) <: AbstractArray for attr in (:line_z, :fill_z, :marker_z)
|
||||
@@ -1069,8 +1068,8 @@ guidefont(ax::Axis) = font(
|
||||
)
|
||||
|
||||
# ---------------------------------------------------------------
|
||||
# converts unicode scientific notation, as returned by Showoff,
|
||||
# to a tex-like format (supported by gr, pyplot, and pgfplots).
|
||||
# converts unicode scientific notation unsupported by pgfplots and gr
|
||||
# into a format that works
|
||||
|
||||
function convert_sci_unicode(label::AbstractString)
|
||||
unicode_dict = Dict(
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
using Plots, Test, Dates
|
||||
|
||||
@testset "Limits" begin
|
||||
y=[1.0*i*i for i in 1:10]
|
||||
x=[Date(2019,11,i) for i in 1:10]
|
||||
|
||||
rx=[x[3],x[5]]
|
||||
|
||||
p = plot(x,y, widen = false)
|
||||
vspan!(p, rx, label="", alpha=0.2)
|
||||
|
||||
ref_ylims = (y[1], y[end])
|
||||
ref_xlims = (x[1].instant.periods.value, x[end].instant.periods.value)
|
||||
@test Plots.ylims(p) == ref_ylims
|
||||
@test Plots.xlims(p) == ref_xlims
|
||||
end # testset
|
||||
@@ -9,14 +9,11 @@ using Gtk
|
||||
using LibGit2
|
||||
import GeometryTypes, GeometryBasics
|
||||
using Dates
|
||||
using RecipesBase
|
||||
|
||||
include("test_axes.jl")
|
||||
include("test_axis_letter.jl")
|
||||
include("test_recipes.jl")
|
||||
include("test_hdf5plots.jl")
|
||||
include("test_pgfplotsx.jl")
|
||||
include("integration_dates.jl")
|
||||
|
||||
reference_dir(args...) = joinpath(homedir(), ".julia", "dev", "PlotReferenceImages", args...)
|
||||
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
using Plots, Test
|
||||
|
||||
@testset "axis letter" begin
|
||||
using Plots, RecipesBase
|
||||
# a custom type for dispacthing the axis-letter-testing recipe
|
||||
struct MyType <: Number
|
||||
val::Float64
|
||||
end
|
||||
value(m::MyType) = m.val
|
||||
data = MyType.(sort(randn(20)))
|
||||
# A recipe that puts the axis letter in the title
|
||||
@recipe function f(::Type{T}, m::T) where T <: AbstractArray{<:MyType}
|
||||
title --> string(plotattributes[:letter])
|
||||
value.(m)
|
||||
end
|
||||
@testset "$f (orientation = $o)" for f in [histogram, barhist, stephist, scatterhist], o in [:vertical, :horizontal]
|
||||
@test f(data, orientation=o).subplots[1].attr[:title] == (o == :vertical ? "x" : "y")
|
||||
end
|
||||
@testset "$f" for f in [hline, hspan]
|
||||
@test f(data).subplots[1].attr[:title] == "y"
|
||||
end
|
||||
@testset "$f" for f in [vline, vspan]
|
||||
@test f(data).subplots[1].attr[:title] == "x"
|
||||
end
|
||||
end
|
||||
+19
-52
@@ -21,12 +21,12 @@ end
|
||||
@test !haskey(axis.contents[1].options.dict, "fill")
|
||||
|
||||
@testset "Legends" begin
|
||||
legends_plot = plot(rand(5, 2), lab = ["1" ""])
|
||||
scatter!(legends_plot, rand(5))
|
||||
legends_plot = plot( rand(5,2), lab = ["1" ""] )
|
||||
scatter!(legends_plot, rand(5) )
|
||||
Plots._update_plot_object(legends_plot)
|
||||
axis_contents = Plots.pgfx_axes(legends_plot.o)[1].contents
|
||||
leg_entries = filter(x -> x isa PGFPlotsX.LegendEntry, axis_contents)
|
||||
series = filter(x -> x isa PGFPlotsX.Plot, axis_contents)
|
||||
leg_entries = filter( x -> x isa PGFPlotsX.LegendEntry, axis_contents )
|
||||
series = filter( x -> x isa PGFPlotsX.Plot, axis_contents )
|
||||
@test length(leg_entries) == 2
|
||||
@test !haskey(series[1].options.dict, "forget plot")
|
||||
@test haskey(series[2].options.dict, "forget plot")
|
||||
@@ -91,8 +91,8 @@ end
|
||||
scatter!(pic, rand(100), markersize = 6, c = :orange)
|
||||
Plots._update_plot_object(pic)
|
||||
axis_contents = Plots.pgfx_axes(pic.o)[1].contents
|
||||
leg_entries = filter(x -> x isa PGFPlotsX.LegendEntry, axis_contents)
|
||||
series = filter(x -> x isa PGFPlotsX.Plot, axis_contents)
|
||||
leg_entries = filter( x -> x isa PGFPlotsX.LegendEntry, axis_contents )
|
||||
series = filter( x -> x isa PGFPlotsX.Plot, axis_contents )
|
||||
@test length(leg_entries) == 2
|
||||
@test length(series) == 4
|
||||
@test haskey(series[1].options.dict, "forget plot")
|
||||
@@ -106,7 +106,7 @@ end
|
||||
end), Plots._shape_keys)
|
||||
markers = reshape(markers, 1, length(markers))
|
||||
n = length(markers)
|
||||
x = (range(0, stop = 10, length = n + 2))[2:(end-1)]
|
||||
x = (range(0, stop = 10, length = n + 2))[2:(end - 1)]
|
||||
y = repeat(reshape(reverse(x), 1, :), n, 1)
|
||||
scatter(
|
||||
x,
|
||||
@@ -231,7 +231,7 @@ end
|
||||
# TODO: support :semi
|
||||
end # testset
|
||||
@testset "Quiver" begin
|
||||
x = (-2pi):0.2:(2*pi)
|
||||
x = (-2pi):0.2:(2 * pi)
|
||||
y = sin.(x)
|
||||
|
||||
u = ones(length(x))
|
||||
@@ -255,7 +255,7 @@ end
|
||||
nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
|
||||
@test length(nodes) == 1
|
||||
mktempdir() do path
|
||||
file_path = joinpath(path, "annotations.tex")
|
||||
file_path =joinpath(path,"annotations.tex")
|
||||
@test_nowarn savefig(pgfx_plot, file_path)
|
||||
open(file_path) do io
|
||||
lines = readlines(io)
|
||||
@@ -271,7 +271,7 @@ end
|
||||
nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
|
||||
@test length(nodes) == 3
|
||||
mktempdir() do path
|
||||
file_path = joinpath(path, "annotations.tex")
|
||||
file_path =joinpath(path,"annotations.tex")
|
||||
@test_nowarn savefig(pgfx_plot, file_path)
|
||||
open(file_path) do io
|
||||
lines = readlines(io)
|
||||
@@ -296,14 +296,14 @@ end
|
||||
nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
|
||||
@test length(nodes) == 9
|
||||
mktempdir() do path
|
||||
file_path = joinpath(path, "annotations.tex")
|
||||
file_path =joinpath(path,"annotations.tex")
|
||||
@test_nowarn savefig(annotation_plot, file_path)
|
||||
open(file_path) do io
|
||||
lines = readlines(io)
|
||||
@test count(s -> occursin("node", s), lines) == 9
|
||||
end
|
||||
# test .tikz extension
|
||||
file_path = joinpath(path, "annotations.tikz")
|
||||
file_path =joinpath(path,"annotations.tikz")
|
||||
@test_nowarn savefig(annotation_plot, file_path)
|
||||
@test_nowarn open(file_path) do io
|
||||
end
|
||||
@@ -326,18 +326,6 @@ end
|
||||
@test ribbon_plot.o !== nothing
|
||||
@test ribbon_plot.o.the_plot !== nothing
|
||||
end # testset
|
||||
@testset "Markers and Paths" begin
|
||||
pl = plot(
|
||||
5 .- ones(9),
|
||||
markershape = [:utriangle, :rect],
|
||||
markersize = 8,
|
||||
color = [:red, :black],
|
||||
)
|
||||
Plots._update_plot_object(pl)
|
||||
axis = Plots.pgfx_axes(pl.o)[1]
|
||||
plots = filter(x -> x isa PGFPlotsX.Plot, axis.contents)
|
||||
@test length(plots) == 9
|
||||
end # testset
|
||||
end # testset
|
||||
|
||||
@testset "Extra kwargs" begin
|
||||
@@ -347,44 +335,27 @@ end # testset
|
||||
@test pl[1].attr[:extra_kwargs][:test] == "me"
|
||||
pl = plot(1:5, test = "me", extra_kwargs = :plot)
|
||||
@test pl.attr[:extra_plot_kwargs][:test] == "me"
|
||||
pl = plot(
|
||||
1:5,
|
||||
extra_kwargs = Dict(
|
||||
:plot => Dict(:test => "me"),
|
||||
:series => Dict(:and => "me too"),
|
||||
),
|
||||
)
|
||||
pl = plot(1:5, extra_kwargs = Dict(:plot => Dict(:test => "me"), :series => Dict(:and => "me too")))
|
||||
@test pl.attr[:extra_plot_kwargs][:test] == "me"
|
||||
@test pl[1][1].plotattributes[:extra_kwargs][:and] == "me too"
|
||||
pl = plot(
|
||||
plot(1:5, title = "Line"),
|
||||
scatter(
|
||||
1:5,
|
||||
title = "Scatter",
|
||||
extra_kwargs = Dict(:subplot => Dict("axis line shift" => "10pt")),
|
||||
),
|
||||
plot(1:5, title="Line"),
|
||||
scatter(1:5, title="Scatter", extra_kwargs=Dict(:subplot=>Dict("axis line shift" => "10pt")))
|
||||
)
|
||||
Plots._update_plot_object(pl)
|
||||
axes = Plots.pgfx_axes(pl.o)
|
||||
@test !haskey(axes[1].options.dict, "axis line shift")
|
||||
@test haskey(axes[2].options.dict, "axis line shift")
|
||||
pl = plot(
|
||||
x -> x,
|
||||
-1:1;
|
||||
add = raw"\node at (0,0.5) {\huge hi};",
|
||||
extra_kwargs = :subplot,
|
||||
)
|
||||
pl = plot(x->x, -1:1; add = raw"\node at (0,0.5) {\huge hi};", extra_kwargs = :subplot)
|
||||
@test pl[1][:extra_kwargs] == Dict(:add => raw"\node at (0,0.5) {\huge hi};")
|
||||
Plots._update_plot_object(pl)
|
||||
axes = Plots.pgfx_axes(pl.o)
|
||||
@test filter(x -> x isa String, axes[1].contents)[1] ==
|
||||
raw"\node at (0,0.5) {\huge hi};"
|
||||
@test filter(x->x isa String, axes[1].contents)[1] == raw"\node at (0,0.5) {\huge hi};"
|
||||
plot!(pl)
|
||||
@test pl[1][:extra_kwargs] == Dict(:add => raw"\node at (0,0.5) {\huge hi};")
|
||||
Plots._update_plot_object(pl)
|
||||
axes = Plots.pgfx_axes(pl.o)
|
||||
@test filter(x -> x isa String, axes[1].contents)[1] ==
|
||||
raw"\node at (0,0.5) {\huge hi};"
|
||||
@test filter(x->x isa String, axes[1].contents)[1] == raw"\node at (0,0.5) {\huge hi};"
|
||||
end # testset
|
||||
|
||||
@testset "Titlefonts" begin
|
||||
@@ -400,11 +371,7 @@ end # testset
|
||||
@test pl[:plot_title] == "Test me"
|
||||
@test pl[:plot_titlefontsize] == 2
|
||||
@test pl[:plot_titlefonthalign] == :left
|
||||
pl = heatmap(
|
||||
rand(3, 3),
|
||||
colorbar_title = "Test me",
|
||||
colorbar_titlefont = (12, :right),
|
||||
)
|
||||
pl = heatmap(rand(3,3), colorbar_title = "Test me", colorbar_titlefont = (12, :right))
|
||||
@test pl[1][:colorbar_title] == "Test me"
|
||||
@test pl[1][:colorbar_titlefontsize] == 12
|
||||
@test pl[1][:colorbar_titlefonthalign] == :right
|
||||
|
||||
@@ -4,21 +4,3 @@ using Plots, Test
|
||||
lens!(pl, [1,2], [1,2], inset = (1, bbox(0.0,0.0,0.2,0.2)))
|
||||
@test length(pl.series_list) == 4
|
||||
end # testset
|
||||
|
||||
@testset "vline, vspan" begin
|
||||
vl = vline([1], widen = false)
|
||||
@test Plots.xlims(vl) == (1,2)
|
||||
@test Plots.ylims(vl) == (1,2)
|
||||
vl = vline([1], xlims=(0,2), widen = false)
|
||||
@test Plots.xlims(vl) == (0,2)
|
||||
vl = vline([1], ylims=(-3,5), widen = false)
|
||||
@test Plots.ylims(vl) == (-3,5)
|
||||
|
||||
vsp = vspan([1,3], widen = false)
|
||||
@test Plots.xlims(vsp) == (1,3)
|
||||
@test Plots.ylims(vsp) == (0,1) # TODO: might be problematic on log-scales
|
||||
vsp = vspan([1,3], xlims=(-2,5), widen = false)
|
||||
@test Plots.xlims(vsp) == (-2,5)
|
||||
vsp = vspan([1,3], ylims=(-2,5), widen = false)
|
||||
@test Plots.ylims(vsp) == (-2,5)
|
||||
end # testset
|
||||
|
||||
Reference in New Issue
Block a user