Update precompile_*.jl file

Co-authored-by: Will Tebbutt <will.tebbutt@invenialabs.co.uk>

.gitattributes

@@ -0,0 +1,6 @@
+# Set default behaviour to automatically normalize line endings.
+* text=auto
+
+# Force bash scripts to always use lf line endings so that if a repo is accessed
+# in Unix via a file share from Windows, the scripts will work.
+*.sh text eol=lf

.github/ISSUE_TEMPLATE/bug.md

@@ -0,0 +1,32 @@
+---
+name: Bug report
+about: Create a bug report
+title: "[BUG]"
+labels: bug
+assignees: ''
+
+---
+
+<!-- Please search existing issues to avoid duplicates. -->
+
+## Details
+
+
+### Backends
+
+This bug occurs on ( insert `x` below )
+
+Backend      | yes | no  | untested
+-------------|-----|-----|---------
+gr (default) |     |     |
+pyplot       |     |     |
+plotly       |     |     |
+plotlyjs     |     |     |
+pgfplotsx    |     |     |
+inspectdr    |     |     |
+
+### Versions
+
+Plots.jl version:
+Backend  version (`]st -m`):
+Output of `versioninfo()`:

.github/ISSUE_TEMPLATE/feature request.md

@@ -0,0 +1,10 @@
+---
+name: Feature request
+about: Suggest a feature or enhancement
+title: "[FR]"
+labels: feature request
+assignees: ''
+
+---
+
+Please search existing issues to avoid duplicates.

.github/workflows/CompatHelper.yml

@@ -0,0 +1,17 @@
+name: CompatHelper
+
+on:
+  schedule:
+    - cron: '00 00 * * *'
+
+jobs:
+  CompatHelper:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Pkg.add("CompatHelper")
+        run: julia -e 'using Pkg; Pkg.add("CompatHelper")'
+      - name: CompatHelper.main()
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          COMPATHELPER_PRIV: ${{ secrets.COMPATHELPER_PRIV }}  # optional
+        run: julia -e 'using CompatHelper; CompatHelper.main()'

.github/workflows/SnoopCompile.yml

@@ -0,0 +1,89 @@
+name: SnoopCompile
+
+on:
+  push:
+    branches:
+    #  - 'master'  # NOTE: to run the bot only on pushes to master
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  SnoopCompile:
+    if: "!contains(github.event.head_commit.message, '[skip ci]')"
+    env:
+      GKS_ENCODING: "utf8"
+      GKSwstype: "100"
+      PLOTS_TEST: "true"
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        version:   # NOTE: the versions below should match those in your botconfig
+          - '1.5'
+        os:        # NOTE: should match the os setting of your botconfig
+          - ubuntu-latest
+        arch:
+          - x64
+    steps:
+      # Setup environment
+      - uses: actions/checkout@v2
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: ${{ matrix.version }}
+
+      - name: Install dependencies
+        run: |
+          julia --project -e 'using Pkg; Pkg.instantiate();'
+          julia -e 'using Pkg; Pkg.add( PackageSpec(name = "CompileBot", version = "1") ); Pkg.develop(PackageSpec(; path=pwd())); using CompileBot; CompileBot.addtestdep();'
+
+
+      # TESTCMD
+      - name: Default TESTCMD
+        run: echo ::set-env name=TESTCMD::"julia"
+      - name: Ubuntu TESTCMD
+        if: startsWith(matrix.os,'ubuntu')
+        run: echo ::set-env name=TESTCMD::"xvfb-run --auto-servernum julia"
+
+      # Generate precompile files
+      - name: Generating precompile files
+        run: $TESTCMD --project -e 'include("deps/SnoopCompile/snoop_bot.jl")'   # NOTE: must match path
+
+      # Run benchmarks
+      - name: Running Benchmark
+        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
+        with:
+          path: ./
+
+  Create_PR:
+    if: "!contains(github.event.head_commit.message, '[skip ci]')"
+    needs: SnoopCompile
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Download all
+        uses: actions/download-artifact@v2
+
+      - name: CompileBot postprocess
+        run: julia -e 'using Pkg; Pkg.add( PackageSpec(name = "CompileBot", version = "1") ); using CompileBot; CompileBot.postprocess();'
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          commit-message: Update precompile_*.jl file
+          title: "[AUTO] Update precompiles"
+          labels: SnoopCompile
+          branch: "SnoopCompile_AutoPR"
+
+
+  Skip:
+    if: "contains(github.event.head_commit.message, '[skip ci]')"
+    runs-on: ubuntu-latest
+    steps:
+      - name: Skip CI 🚫
+        run: echo skip ci

.github/workflows/TagBot.yml

@@ -0,0 +1,14 @@
+name: TagBot
+on:
+  issue_comment:
+    types:
+      - created
+  workflow_dispatch:
+jobs:
+  TagBot:
+    if: github.event_name == 'workflow_dispatch' || github.actor == 'JuliaTagBot'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: JuliaRegistries/TagBot@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -0,0 +1,85 @@
+name: ci
+
+on:
+  push:
+  pull_request:
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  CI:
+    if: "!contains(github.event.head_commit.message, '[skip ci]')"
+    env:
+      GKS_ENCODING: "utf8"
+
+    name: Julia ${{ matrix.version }} - ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.version == 'nightly' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - '1'
+          - 'nightly'
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macos-latest
+        arch:
+          - x64
+          # - x86
+
+    steps:
+
+      # Setup environment
+      - uses: actions/checkout@v2
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: ${{ matrix.version }}
+      - name: Cache artifacts
+        uses: actions/cache@v1
+        env:
+          cache-name: cache-artifacts
+        with:
+          path: ~/.julia/artifacts
+          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-test-${{ env.cache-name }}-
+            ${{ runner.os }}-test-
+            ${{ runner.os }}-
+
+      ## maybe required if we ever want to run graphical tests for plotly
+      # OS Dependencies
+      # - name: Ubuntu OS dependencies
+      #   if: startsWith(matrix.os,'ubuntu')
+      #   run: |
+      #    ./test/install_wkhtmltoimage.sh
+
+      # TESTCMD
+      - name: Default TESTCMD
+        run: echo ::set-env name=TESTCMD::"julia"
+      - name: Ubuntu TESTCMD
+        if: startsWith(matrix.os,'ubuntu')
+        run: echo ::set-env name=TESTCMD::"xvfb-run --auto-servernum julia"
+
+      # Julia Dependencies
+      - name: Install Julia dependencies
+        uses: julia-actions/julia-buildpkg@latest
+
+      # Run tests
+      - name: Run Graphical test
+        run:  $TESTCMD --project -e 'using Pkg; Pkg.test(coverage=true);'
+
+      - name: Codecov
+        uses: julia-actions/julia-uploadcodecov@latest
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  Skip:
+    if: "contains(github.event.head_commit.message, '[skip ci]')"
+    runs-on: ubuntu-latest
+    steps:
+      - name: Skip CI 🚫
+        run: echo skip ci

.gitignore

@@ -1,4 +1,12 @@
 *.jl.cov
 *.jl.*.cov
 *.jl.mem
-.DS_Store
+.DS_Store
+examples/.ipynb_checkpoints/*
+examples/meetup/.ipynb_checkpoints/*
+deps/plotly-*
+deps/build.log
+deps/deps.jl
+Manifest.toml
+dev/
+test/tmpplotsave.hdf5

.travis.yml

@@ -1,13 +0,0 @@
-# Documentation: http://docs.travis-ci.com/user/languages/julia/
-language: julia
-os:
-  - linux
-  - osx
-julia:
-  - 0.4
-notifications:
-  email: false
-# uncomment the following lines to override the default test script
-script:
- - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
- - julia -e 'Pkg.clone(pwd()); Pkg.build("Plots"); Pkg.add("Gadfly"); Pkg.test("Plots"; coverage=true)'

NEWS.md

@@ -0,0 +1,824 @@
+
+# Plots.jl NEWS
+
+#### notes on release changes, ongoing development, and future planned work
+
+## (current master)
+
+## 0.28.3
+- support generalized array interface
+- save to pdf, svg and eps in plotlyjs
+- fix for clims in line_z
+- optimize heatmap logic in gr
+
+## 0.26.3
+- fix `vline` with dates
+- fix PyPlot logscale bug
+- avoid annotation clipping for PyPlot
+- allow plotting of Any vectors and 3D plotting again in convertToAnyVector
+- specify legend title font in GR and PyPlot
+- delete `pushtomaster.sh`
+- use `=== nothing`
+
+## 0.26.2
+- improve empty animation build error
+- fix GR axis flip for heatmaps and images
+- fix ribbons specified as tuples
+- add Char recipe
+- fix Plotly plots with single-element series
+- rewrite PlotlyJS backend
+
+## 0.26.1
+- handle `Char`s as input data
+- fix html saving for Plotly
+- expand ~ in paths on UNIX systems
+- convertToAnyVector clean-up
+- fix color_palette grouping issue
+
+## 0.26.0
+- use FFMPEG.jl
+- add missing method for convertToAnyVector
+
+## 0.25.3
+- add areaplot
+- allow missing in z_color arguments
+- more general tuple recipe
+- stephist logscale improvements
+
+## 0.25.2
+- improvements to handle missings
+- pyplot: allow setting the color gradient for z values
+- document :colorbar_entry
+- limit number of automatic bins
+- fix ENV['PLOTS_DEFAULT_BACKEND']
+- don't let aspect_ratio impact subplot size
+- implement arrowstyle for GR
+- fix bug in plotly_convert_to_datetime
+- improve missing support
+- gr: polar heatmaps
+- make sure show returns nothing
+
+## 0.25.1
+- fix gr_display
+
+## 0.25.0
+- Replace StaticArrays with GeometryTypes
+- Contour fixes for GR
+
+## 0.24.0
+- Update to the new PyCall and PyPlot API
+- fix drawing of ticks
+- fix y label position with GR
+
+## 0.23.2
+- pyplot fixes
+- Add option :tex_output_standalone to set the 'include_preamble' argument in the PGFPlots backend.
+- fix ticks
+- support plotly json mime
+- fix image axis limits
+- default to radius 0 at center for polar plots
+
+## 0.23.1
+- slightly faster load time
+- fixed errant MethodError
+- fix bar plots with unicodeplots
+- better colorbars for contour
+- add volume seriestype for GR
+- fix passing a tuple to custom ticks
+- add vline to pgfplots
+- add tex output for pyplot
+- better 3d axis labels for GR
+
+## 0.23.0
+- compatible with StatPlots -> StatsPlots name shift
+- fix histograms for vectors with NaN and Inf
+- change gif behaviour (remove cache-busting)
+- improved docstrings for shorthands functions
+- fix font rotation for pyplot
+- fix greyscale images for pyplot
+- clamp greyscale images with values outside 0,1
+- support keyword argument for font options
+- allow vector of markers for pyplot scatter
+
+## 0.22.5
+- improve behaviour of plotlyjs backend
+
+## 0.22.4
+- Add support for discrete contourf plots with GR
+
+## 0.22.3
+- Fix the `showtheme` function
+
+## 0.22.2
+- Allow annotations to accept a Tuple instead of the result of a text call (making it possible to specify font characteristics in recipes). E.g. `annotations = (2, 4, ("test", :right, 8, :red))` is the same as `annotations = (2, 4, text("test", :right, 8, :red))`
+
+## 0.22.1
+- push PlotsDisplay just after REPLDisplay
+
+## 0.22.0
+- deprecate GLVisualize
+- allow 1-row and 1-column heatmaps
+- add portfoliodecomposition recipe from PlotRecipes
+- solve Shape bug
+- simplify PyPlot backend installation
+- fix wireframe bug in PyPlot
+- fix color bug in PyPlot
+- minor bug fixes in gr and pyplot
+
+## 0.21.0
+- Compatibility with StaticArrays 0.9.0
+- Up GR min version to 0.35
+- fix :mirror
+
+## 0.20.6
+- fixes for PlotDocs.jl
+- fix gr axis color argument
+- Shapes for inspectdr
+- don't load plotly js file by default
+
+## 0.20.5
+- fix precompilation issue when depending on Plots
+
+## 0.20.4
+- honour `html_output_format` in Juno
+
+## 0.20.3
+- implement guide position in gr, pyplot and pgfplots
+- inspectdr fixes
+- default appveyor
+- rudimentary missings support
+- deprecation fixes for PGFPlots
+
+## 0.20.0
+Many updates, min julia 1.0
+- change display type to use PlotsDisplay (fixes Juno integration)
+- change all internal uses of `d` to `plotattributes` (no user change)
+- change spy implementation to use `scatter` not `heatmap`
+- sort x axes when passing a vector of strings as x
+- improve performance of marker_z
+- update CI to 1.0
+- minor depwarn ifixes
+- only draw one colorbar with GR
+- add colorbar_title to GR and pgfplots
+- fix savefig with latexstrings for PyPlot
+- fix NamedTuple integration
+- don't export `P2` and `P3`
+- make it possible to use 2-argument function as argument to marker_z
+- make `plotattr` work again
+
+## 0.19.3
+- fix some julia 0.7 deprecations
+- fix 32-bit OS functionality
+
+## 0.19.2
+- several small fixes for 1.0 compatibility
+
+## 0.19.1
+- don't broadcast plot_color
+
+## 0.19.0
+- Refactor conditional loading to use Requires
+- Many fixes for 1.0 compatibility
+
+## 0.18.0
+- update minor version to 0.7
+
+## 0.17.4
+- fix thickness_scaling for pyplot
+
+## 0.17.3
+- Log-scale heatmap edge computation
+- Fix size and dpi for GR and PyPlot
+- Fix fillrange with line segments on PyPlot and Plotly
+- fix flip for heatmap and image on GR
+- New attributes for PGFPlots
+- Widen axes for most series types and log scales
+- Plotly: fix log scale with no ticks
+- Fix axis flip on Plotly
+- Fix hover and zcolor interaction in Plotly
+- WebIO integration for PlotlyJS backend
+
+## 0.17.2
+- fix single subplot in plotly
+- implement `(xyz)lims = :round`
+- PyPlot: fix bg_legend = invisible()
+- set fallback tick specification for axes with discrete values
+- restructure of show methods
+
+## 0.17.1
+- Fix contour for PGFPlots
+- 32Bit fix: Int64 -> Int
+- Make series of shapes and segments toggle together in Plotly(JS)
+- Fix marker arguments
+- Fix processing order of series recipes
+- Fix Plotly(JS) ribbon
+- Contour plots with x,y in grid form on PyPlot
+
+## 0.17.0
+- Add GR dependency to make it the default backend
+- Improve histogram2d bin estimation
+- Allow vector arguments for certain series attributes and support line_z and fill_z on GR, PyPlot, Plotly(JS) and PGFPlots
+- Automatic scientific notation for tick labels
+- Allow to set the theme in PLOTS_DEFAULTS
+- Implement plots_heatmap seriestype providing a Plots recipe for heatmaps
+
+## 0.16.0
+- fix 3D plotting in PyPlot
+- Infinite objects
+
+## 0.15.1
+
+- fix scientific notation for labels in GR
+- fix labels with logscale
+- fix image cropping with GR
+- fix grouping of annotations
+- fix annotations in Plotly
+- allow saving notebook with plots as pdf from IJulia
+- fix fillrange and ribbon for step recipes
+- implement native ticks that respond to zoom
+- fix bar plot with one bar
+- contour labels and colorbar fixes
+- interactive linked axis for PyPlot
+- add `NamedTuple` syntax to group with named legend
+- use bar recipe in Plotly
+- implement categorical ticks
+
+## 0.15.0
+
+- improve resolution of png output of GR with savefig()
+- add check for ticks=nothing
+- allow transparency in heatmaps
+- fix line_z for GR
+- fix legendcolor for pyplot
+- fix pyplot ignoring alpha values of images
+- don't let `abline!` change subplot limits
+- update showtheme recipe
+
+## 0.14.2
+
+- fix plotly bar lines bug
+- allow passing multiple series to `ribbon`
+- add a new example for `line_z`
+
+## 0.14.1
+
+- Add linestyle argument to the legend
+- Plotly: bar_width and stroke_width support for bar plots
+- abline! does not change axis limits
+- Fix default log scale ticks in GR backend
+- Use the :fontsize keys so the scalefontsizes command works
+- Prepare support for new PlotTheme type in PlotThemes
+
+## 0.14.0
+
+- remove use of imagemagick; saving gifs now requires ffmpeg
+- improvements to ffmpeg gif quality and speed
+- overhaul of fonts, allows setting fonts in recipes and with magic arguments
+- added `camera` attribute to control camera position for 3d plots
+- added `showaxis` attribute to control which axes to display
+- improvements of polar plots axes, and better backend consistency
+- changed the 'spy' recipe back to using heatmap
+- added `scatterpath` seriestype
+- allow plotlyjs to save svg
+- add `reset_defaults()` function to reset plot defaults
+- update syntax to 0.6
+- make `fill = true` fill to 0 rather than to 1
+- use new `@df` syntax in StatsPlots examples
+- allow changing the color of legend box
+- implement `title_location` for gr
+- add `hline` marker to pgfplots - fixes errorbars
+- pyplot legends now show marker types
+- pyplot colorbars take font style from y axis
+- pyplot tickmarks color the same as axis color
+- allow setting linewidth for contour in gr
+- allow legend to be outside plot area for pgfplots
+- expand axis extrema for heatmap
+- extendg grid lines to axis limits
+- fix `line_z` for pyplot and gr
+- fixed colorbar problem for flipped axes with gr
+- fix marker_z for 3d plots in gr
+- fix `weights` functionality for histograms
+- fix gr annotations with colorbar
+- fix aspect ratio in gr
+- fix "hidden window" problem after savefig in gr
+- fix pgfplots logscale ticks error
+- fix pgfplots legends symbols
+- fix axis linking for plotlyjs
+- fix plotting of grayscale images
+
+## 0.13.1
+
+- fix a bug when passing a vector of functions with no bounds (e.g. `plot([sin, cos])`)
+- export `pct` and `px` from Plots.PlotMeasures
+
+## 0.13.0
+
+- support `plotattributes` rather than `d` in recipes
+- no longer export `w`, `h` and names from Measures.jl; use `using Plots.PlotMeasures` to get these names back
+- `bar_width` now depends on the minimum distance between bars, not the mean
+- better automatic x axis limits for plotting Functions
+- `tick_direction` attribute now allows ticks to be on the inside of the plot border
+- removed a bug where `p1 = plot(randn(10)); plot(p1, p2)` made `display(p1)` impossible
+- allow `plot([])` to generate an empty plot
+- add `origin` framestyle
+- ensure finite bin number on histograms with only one unique value
+- better automatic histogram bins for 2d histograms
+- more informative error message on passing unsupported seriestype in a recipe
+- allow grouping in user recipes
+- GR now has `line_z` and `fill_z` attributes for determining the color of shapes and lines
+- change GR default view angle for 3D plots to match that of PyPlot
+- fix `clims` on GR
+- fix `marker_z` for plotly backend
+- implement `framestyle` for plotly
+- fix logscale bug error for values < 1e-16 on pyplot
+- fix an issue on pyplot where >1 colorbar would be shown if there was >1 series
+- fix `writemime` for eps
+
+## 0.12.4
+
+- added a new `framestyle` argument with choices: :box, :semi, :axes, :grid and :none
+- changed the default bar width to 0.8
+- added working ribbon to plotly backend
+- ensure that automatic ticks always generate 4 to 8 ticks
+- group now groups keyword arguments of the same length as the input
+- allow passing DateTime objects as ticks
+- allow specifying the number of ticks as an integre
+- fix bug on errorbars in gr
+- fixed some but not all world age issues
+- better margin with room for text
+- added a `match` option for linecolor
+- better error message un unsupported series types
+- add a 'stride' keyword for the pyplot backend
+
+## 0.12.3
+
+- new grid line style defaults
+- `grid` is now an axis attribute and a magic argument: it is now possible to modify the grid line style, alpha and line width
+- Enforce plot order in user recipes
+- import `plot!` from RecipesBase
+- GR no longer automatically handles _ and ^ in texts
+- fix GR colorbar for scatter plots
+
+#### 0.12.2
+
+- fix an issue with Juno/PlotlyJS compatibility on new installations
+- fix markers not showing up in seriesrecipes using :scatter
+- don't use pywrap in the pyplot backend
+- improve the bottom margin for the gr backend
+
+#### 0.12.1
+
+- fix deprecation warnings
+- switch from FixedSizeArrays to StaticArrays.FixedSizeArrays
+- drop FactCheck in tests
+- remove julia 0.5 compliant uses of transpose operator
+- fix GR heatmap bugs
+- fix GR guide padding
+- improve legend markers in GR
+- add surface alpha for Plotly(JS)
+- add fillrange to Plotly(JS)
+- allow usage of Matplotlib 1.5 with PyPlot
+- fix GLVisualize for julia 0.6
+- conform to changes in InspectDR
+
+#### 0.12.0
+
+- 0.6 only
+
+#### 0.11.3
+
+- add HDF5 backend
+- GR replaces PyPlot as first-choice backend
+- support for legend position in GR
+- smaller markers in GR
+- better viewport size in GR
+- fix glvisualize support
+- remove bug with three-argument method of `text`
+- `legendtitle` attribute added
+- add test for `spy`
+
+#### 0.11.0
+
+- julia 0.6 compatibility
+- matplotlib 2.0 compatibility
+- add inspectdr backend
+- improved histogram functionality:
+- added a `:stephist` and `:scatterhist` series type as well as ``:barhist` (the default)
+- support for log scale axes with histograms
+- support for plotting `StatsBase.Histogram`
+- allowing bins to be specified as `:sturges`, `:rice`, `:scott` or :fd
+- allow `normalization` to be specified as :density (for unequal bins) or :pdf (sum to 1)
+- add a `plotattr` function to access documentation for Plots attribute
+- add `fill_z` attribute for pyplot
+- add colorbar_title to plotlyjs
+- enable standalone window for plotlyjs
+- improved support for pgfplots, ticks rotation, clims, series_annotations
+- restore colorbars for GR
+- better axis labels for heatmap in GR
+- better marker sizes in GR
+- fix color representation in GR
+- update GR legend
+- fix image bug on GR
+- fix glvisualize dependencies
+- set dotted grid lines for pyplot
+- several improvements to inspectdr
+- improved tick positions for TimeType x axes
+- support for improved color gradient capability in PlotUtils
+- add a showlibrary recipe to display color libraries
+- add a showgradient recipe to display color gradients
+- add `vectorfield` as an alias for `quiver`
+- use `PlotUtils.adaptedgrid` for functions
+
+
+#### 0.9.5
+
+- added dependency on PlotThemes
+- set_theme --> theme
+- remove Compat from REQUIRE
+- warning for DataFrames without StatsPlots
+- closeall exported and implemented for gr/pyplot
+- fix DateTime recipe
+- reset theme with theme(:none)
+- fix link_axes! for nested subplots
+- fix plotly lims for log scale
+
+#### 0.9.4
+
+- optimizations surrounding Subplot.series_list
+- better Atom support, support plotlyjs
+- gr:
+    - gks_wstype defaults and gr_set_output
+    - heatmap uses GR.drawimage
+- histogram2d puts NaN for zeros
+- improved support of NaN in heatmaps
+- rebuilt spy recipes to output scatters with marker_z set
+- deprecate png support in plotly... point to plotlyjs
+- fixes:
+    - axis widen with lims set
+    - reset_extrema, setxyz
+    - bar plot widen
+    - better tick padding
+    - consistent tick rotation
+    - consistent aspect_ratio
+    - pyplot dpi
+    - plotly horizontal bars
+    - handle series attributes when combining subplots
+    - gr images transposed
+    - converted Date/DateTime to new type recipe approach for arrays
+- issues closed include: #505 #513 #479 #523 #526 #529
+
+#### 0.9.3
+
+- support pdf and eps in plotlyjs backend
+- allow curly after grid: `@layout [a b; grid(4,4){0.8h}]`
+- add_backend redesign
+
+#### 0.9.2
+
+- glvisualize backend (@SimonDanisch)
+    - too much to list! ready for alpha testing
+- Volume and volume seriestype
+- Atom: support for PlotPane and proper gui display
+- gr:
+    - clims
+    - aspect ratio
+- pgfplots:
+    - fixes for ticks, axes, and more
+- pyplot:
+    - font families
+    - colorbar guide
+    - pixel marker
+- unicodeplots
+    - basic support for shapes
+- improved add_backend
+- refactor of is_supported methods
+- element-wise type recipes (see https://github.com/tbreloff/Plots.jl/issues/460#issuecomment-248428908)
+- several other fixes/improvements
+
+#### 0.9.1
+
+- Pkg.dir --> dirname (@tkelman)
+- `axis = nothing` magic
+- fixes:
+    - clim for line_z
+    - sticks default range for log scale
+    - rotate method
+    - pyplot heatmap
+    - spurious scale warnings
+    - gr image/alpha
+    - plotly.js path
+    - orientation extrema
+    - bar, reset orientation
+- switch transpose_z to use permutedims
+- skinny x/+ markers
+- ticks in pgfplots
+- eps in savefig (@anriseth)
+- add_backend convenience
+- type recipes for Date/DateTime (@maximsch2)
+- mirror attribute and twinx convenience
+- Axis.sp --> Axis.sps
+- recipe postprocessing for allowing aliases and magic args in recipe bodies
+
+
+
+#### 0.9.0
+
+- fixes to cycle
+- add back single function recipe: `plot!(cos)`
+- new axis formatter attribute... accepts functions to convert numbers to strings
+- fix for inset plots
+- GR:
+	- fillrange fix
+	- annotations fix
+	- force double buffering in display
+
+---
+
+## 0.8
+
+#### 0.8.2 (backported bug fixes for julia 0.4)
+
+- plotly ticks fix
+- unicodeplots size fix
+- remove mkdir call in tests
+
+#### 0.8.1
+
+- manual drawing of axes/ticks/labels
+- get_ticks uses optimize_ticks and Showoff
+- changed PLOTS_DEFAULTS to be a global variable, not ENV key
+- parameterized Segments for pushing tuples
+- fix to axis extrema for Bool/nothing
+- GR:
+	- manually draw 2D axes... fixes several issues and missing features
+	- fontsize fix
+- PGFPlots: pass axis syle
+
+#### 0.8.0
+
+- added dependency on PlotUtils
+- BREAKING: removed DataFrames support (now in StatsPlots.jl)
+- BREAKING: removed boxplot/violin/density recipes (now in StatsPlots.jl)
+- GR:
+    - inline iterm2 support
+    - trisurface support
+    - heatmap fix
+- PyPlot:
+    - ijulia display fix
+- GLVisualize:
+    - first try with shapes
+- iter_segments improvements
+- bar_width support
+- horizontal bars
+- improve tick display
+- better shape handling in pyplot, plotly
+- improved padding calcs
+- internal reorg of _plots method, add pipeline.jl
+
+---
+
+## 0.7
+
+#### 0.7.5
+
+- GR: LaTeX support
+- Changed docs url to juliaplots.github.io
+- added `contourf` seriestype
+- allow `plt[1]` to return first Subplot
+- allow `sp[1]` to return the first Series of the Subplot
+- `series[k]` now passes through to `series.d[k]`
+- allow calling `plot!(sp, ...)` to update a target Subplot
+- PyPlot: zorder fix
+- new DataFrames logic/recipe: more flexible/robust and allow Symbols for:
+	- `(:fillrange, :line_z, :marker_z, :markersize, :ribbon, :weights, :xerror, :yerror)`
+- new `display_type` and `extra_kwargs` plot attributes
+- surface fix
+
+#### 0.7.4
+
+- added snooped precompiles, but left commented out
+- GR fixes: markersize, shapes, legends
+- fixes to recipes
+- turned on Appveyor
+
+#### 0.7.3
+
+- rebuild violin and boxplot recipes
+- "plot recipes"
+- `cgrad` method for easy color gradient creation
+- improvements to inset subplots
+- Segments and iter_segments for NaN-separated vectors
+- `bar` recipe now creates a `shape` series
+- writemime fix for Interact.jl
+- `link = :square` option
+- !!! set `shape` attributes with line/fill, NOT marker/markerstroke !!!
+- basic DPI support
+- moved chorddiagram to PlotRecipes
+- GR:
+	- use temp files for img output
+	- basic support for marker strokes and other marker fixes
+- PyPlot:
+	- Switch to recipes for bar, histogram, histogram2d
+- GLVisualize
+	- subplots
+	- path/scatter and path3d/scatter3d
+	- initial drawing of axes
+- many smaller fixes and improvements
+
+#### 0.7.2
+
+- line_z arg for multicolored line segments
+- pyplot
+	- line_z (2d and 3d)
+	- pushed all fig updates into display pipeline
+	- remove native sticks/hline/vline in favor of recipes
+- unicodeplots cleanup, ijulia fixes, ascii canvas
+- `curves` series type
+- `iter_segments` iterator
+- moved arcdiagram out and into PlotRecipes (thanks @diegozea)
+- several other fixes/checks
+
+#### 0.7.1
+
+- inset (floating) subplots
+- change: when setting subplot/axis args from user recipes, they should apply only to their own subplot
+- trim for violin/boxplot
+- scatter3d recipe
+- removed plotly.js in favor of build.jl download
+- improvements/fixes to pgfplots backend
+- improvements/fixes to plotly/plotlyjs backends
+	- titles are annotations and properly placed with title_position
+	- hover attribute
+	- shapes (almost)
+	- scattergl
+- minimum perimeter logic in layout calc... fixed misaligned subplots
+- new clims attribute
+- more options for test_examples
+- GR refactor
+	- added transparency
+	- moved axis/grid logic out of series loop
+	- generalized 3d and polar projections
+- renamed get_mod to Base.cycle
+- pyplot log scale fixes
+- PLOTS_DEFAULTS environment var processing
+- rename :ellipse to :circle, :ellipse is now an alias
+- supported args/types cleanup
+- seriestype dependency methods and `@deps` macro
+- bbox `h_anchor`/`v_anchor`
+- new axis arg: `:link` is a list of subplots to link axes with
+- cleanup/simplification of glvisualize backend
+
+
+#### 0.7.0
+
+- Check out [the summary](http://juliaplots.github.io/plots_v0.7/)
+- Revamped and simplified internals
+- [Recipes, recipes, recipes](https://github.com/JuliaPlots/RecipesBase.jl/issues/6)
+- [Layouts and Subplots](https://github.com/tbreloff/Plots.jl/issues/60)
+- DataFrames is loaded automatically when installed
+- Overhaul to GroupBy mechanic (now offloads to a recipe)
+- Replaced much of the argument processing with recipes
+- Added series recipes, and began to strip down un-needed backend code.  Some recipes:
+	- line, step, sticks, bar, histogram, histogram2d, boxplot, violin, quiver, errorbars, density, ohlc
+- Added `@shorthands` and `@userplot` macros for recipe convenience
+- Better handling of errorbars and ribbons
+- New Axis type
+	- Tracks extrema and discrete values
+	- New `link_axes` functionality
+- `linetype` has been renamed `seriestype` (the alias is reversed)
+- Many fixes and huge cleanup in GR
+- Brand new subplot layout mechanics:
+	- `@layout` macro
+	- AbstractLayout, Subplot, GridLayout, and everything related
+	- Added dependency on Measures.jl
+	- Computations of axis/guide sizes and precise positioning
+- Refactored and compartmentalized default dictionaries for attributes
+- Deprecated Gadfly and Immerse backends
+- Added `series_annotations` attribute (previously that functionality was merged with `annotations`, which are not series-specific)
+- Removed `axis` attribute... currently not supporting twin (right) y axes
+- Check for `ENV["PLOTS_USE_ATOM_PLOTPANE"]` and default to false
+- Improved backend interface to reduce redundant code.  Template updated.
+- Added `html_output_format`, primarily for choosing between png and svg output in IJulia.
+- Partial support of Julia v0.5
+- Switched testing to dump reference images to JuliaPlots/PlotReferenceImages.jl
+- Moved docs-specific code to new JuliaPlots/PlotDocs.jl
+- Moved example list from ExamplePlots into Plots.
+- Added several examples and improved others.
+- Many other smaller changes and bug fixes.
+
+
+---
+
+## Version 0.6
+
+#### 0.6.2
+
+- `linewidth` fixes
+- `markershape` fix
+- converted center calc to centroid for shapes
+- new dependency on [RecipesBase](https://github.com/JuliaPlots/RecipesBase.jl)
+- REQUIRE upper limit for RecipesBase: 0.0.1
+- GR fixes/improvements (@jheinen)
+  - support `zlims`, `bins`
+  - allow Plots colormaps
+  - other bug fixes
+  - native image support
+- PGFPlots fixes/improvements (@pkofod)
+- DataFrames are handled by recipes
+- Plotly: zaxis, tick rotation, 3d axis fix
+- Improvements in handling discrete data
+- Support for image display
+- `arrow` keyword and support for adding arrows to paths
+- changed quiver recipe to use arrows
+- Bug fixes for boxplots, heatmaps, and more
+
+#### 0.6.1
+
+- `rotation` keyword
+- improved supported graphs
+- subplot bug fix
+
+#### 0.6.0
+
+- `apply_series_recipe` framework for built-in recipes
+- [boxplot/violin recipes](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/boxplot.ipynb)
+- [errorbar/ribbon recipes](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/errorbars.ipynb)
+- [quiver recipe](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/quiver.ipynb)
+- `polar` coordinates
+- better support for shapes and custom polygons (see [batman](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/batman.ipynb))
+- z-axis keywords
+- 3D indexing overhaul: `push!`, `append!` support
+- matplotlib colormap constants (`:inferno` is the new default colormap for Plots)
+- `const KW = Dict{Symbol,Any}` used in place of splatting in many places
+- png generation for plotly backend using wkhtmltoimage
+- `normalize` and `weights` keywords
+- background/foreground subcategories for fine-tuning of looks
+- `add_theme`/`set_theme` and ggplot2 theme (see [this issue](https://github.com/tbreloff/Plots.jl/issues/201))
+- `PLOTS_DEFAULT_BACKEND` environment variable
+- `barh` linetype
+- support for non-gridded surfaces with pyplot's trisurface
+- pyplot surface zcolor
+- internal refactor of supported.jl
+- `wrap` method to bypass input processing
+- `translate`, `scale` and `rotate` methods for coordinates and shapes
+- and many more minor fixes and improvements
+
+---
+
+## Version 0.5
+
+#### 0.5.4
+
+- old heatmaps have been renamed to hist2d, and true heatmaps implemented (see https://github.com/tbreloff/Plots.jl/issues/147)
+- lots of reorganization and redesign of the internals
+- lots of renaming to keep to conventions: AbstractPlot, AbstractBackend, etc
+- initial redesign of layouts
+- integration with Atom PlotPane
+- arc diagram and chord diagram (thanks to @diegozea: see https://github.com/tbreloff/Plots.jl/issues/163)
+- work on GR, GLVisualize, and PGFPlots backends (thanks @jheinen @dlfivefifty @pkofod)
+- improvements to Plotly setup (thanks @spencerlyon2)
+- overhaul to series creation logic and groupby mechanic
+- replace Dict with `typealias KW Dict{Symbol,Any}` in many places, also replacing keyword arg splatting
+- new `shape` linetype for plotting polygons in plot-coordinates (see https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/batman.ipynb)
+- many other fixes
+
+#### 0.5.3
+
+- `@gif` macro with `every`/`when` syntax
+- bezier curves and other graph drawing helpers
+- added FixedSizeArrays dependency with relevant functionality
+- merged lots of improvements to GR (thanks @jheinen)
+- `overwrite_figure`/`reuse` arg for reusing the same figure window
+- deprecated Qwt, Winston, and Bokeh backends
+- improved handling of 3D inputs (call `z=rand(10,10); surface(z)` for example)
+- fix IJulia display issue
+- lots of progress on PlotlyJS backend
+- and many other changes and fixes...
+
+#### 0.5.2
+
+- Added [GR.jl](https://github.com/jheinen/GR.jl) as a backend (unfinished but functional) All credit to @jheinen
+- Set defaults within backend calls (i.e. `gadfly(legend=false)`)
+- `abline!`; also extrema allows plotting functions without giving x (i.e. `plot(cos, 0, 10); plot!(sin)`) @pkofod @joshday
+- Integration with [PlotlyJS.jl](https://github.com/spencerlyon2/PlotlyJS.jl) for using Plotly inside a Blink window @spencerlyon2
+- The Plotly backend has been split into my built-in version (`plotly()`) and @spencerlyon2's backend (`plotlyjs()`)
+- Revamped backend setup code for easily adding new backends
+- New docs (WIP) at http://juliaplots.github.io/
+- Overhaul to `:legend` keyword (see https://github.com/tbreloff/Plots.jl/issues/135)
+- New dependency on Requires, allows auto-loading of DataFrames support
+- Support for plotting lists of Tuples and FixedSizeArrays
+- new `@animate` macro for super simple animations (see https://github.com/tbreloff/Plots.jl/issues/111#issuecomment-181515616)
+- allow Function for `:fillrange` and `zcolor` arguments (for example: `scatter(sin, 0:10, marker=15, fill=(cos,0.4), zcolor=sin)`)
+- allow vectors of PlotText without x/y coords (for example: `scatter(rand(10), m=20, ann=map(text, 1:10))`)
+- Lots and lots of fixes
+
+#### 0.5.1
+
+#### 0.5.0
+
+- `with` function for temporary defaults
+- contours
+- basic 3D plotting
+- preliminary support for Bokeh
+- `stroke` and `brush` for more fine-tuned control over visuals
+- smarter "magic" arguments: `line`, `marker`

Project.toml

@@ -0,0 +1,76 @@
+name = "Plots"
+uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
+author = ["Tom Breloff (@tbreloff)"]
+version = "1.9.0"
+
+[deps]
+Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+Contour = "d38c429a-6771-53c6-b99e-75d170b6e991"
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+FFMPEG = "c87230d0-a227-11e9-1b43-d7ebe4e7570a"
+FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
+GR = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71"
+GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
+JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
+Latexify = "23fbe1c1-3f47-55db-b15f-69d7ec21a316"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Measures = "442fdcdd-2543-5da2-b0f3-8c86c306513e"
+NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
+PlotThemes = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a"
+PlotUtils = "995b91a9-d308-5afd-9ec6-746e21dbc043"
+Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
+RecipesPipeline = "01d81517-befc-4cb6-b9ec-a95719d0359c"
+Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
+Requires = "ae029012-a4dd-5104-9daa-d747884805df"
+Scratch = "6c6a2e73-6563-6170-7368-637461726353"
+Showoff = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
+UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+
+[compat]
+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, 0.53"
+GeometryBasics = "0.2, 0.3.1"
+JSON = "0.21, 1"
+Latexify = "0.14"
+Measures = "0.3"
+NaNMath = "0.3"
+PlotThemes = "2"
+PlotUtils = "1"
+RecipesBase = "1"
+RecipesPipeline = "0.2"
+Reexport = "0.2"
+Requires = "1"
+Scratch = "1"
+Showoff = "0.3.1"
+StatsBase = "0.32, 0.33"
+julia = "1.5"
+
+[extras]
+Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
+FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
+Gtk = "4c0ca9eb-093a-5379-98c5-f87ac0bbbf44"
+HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
+ImageMagick = "6218d12a-5da1-5696-b52f-db25d2ecc6d1"
+Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
+LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
+OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+PGFPlotsX = "8314cec4-20b6-5062-9cdb-752b83310925"
+RDatasets = "ce6b1742-4840-55fa-b093-852dadbb1d8b"
+StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
+StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+TestImages = "5e47fb64-e119-507b-a336-dd2b206d9990"
+UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
+VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"
+
+[targets]
+test = ["Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "TestImages", "UnicodePlots", "VisualRegressionTests"]

README.md

@@ -1,281 +1,33 @@
 # Plots
 
-[![Build Status](https://travis-ci.org/tbreloff/Plots.jl.svg?branch=master)](https://travis-ci.org/tbreloff/Plots.jl)
+[gh-ci-img]: https://github.com/JuliaPlots/Plots.jl/workflows/ci/badge.svg?branch=master
+[gh-ci-url]: https://github.com/JuliaPlots/Plots.jl/actions?query=workflow%3Aci
 
-#### Author: Thomas Breloff (@tbreloff)
+[pkgeval-img]: https://juliaci.github.io/NanosoldierReports/pkgeval_badges/P/Plots.svg
+[pkgeval-url]: https://juliaci.github.io/NanosoldierReports/pkgeval_badges/report.html
 
-Plotting interface and wrapper for several plotting packages.
+[gitter-img]: https://badges.gitter.im/tbreloff/Plots.jl.svg
+[gitter-url]: https://gitter.im/tbreloff/Plots.jl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
 
-Please add wishlist items, bugs, or any other comments/questions to the issues list.
+[docs-img]: https://img.shields.io/badge/docs-stable-blue.svg
+[docs-url]: http://docs.juliaplots.org/latest/
 
-## Examples for each implemented backend:
+[![][gh-ci-img]][gh-ci-url]
+[![][pkgeval-img]][pkgeval-url]
+[![project chat](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://julialang.zulipchat.com/#narrow/stream/236493-plots)
+[![][docs-img]][docs-url]
+[![Codecov](https://codecov.io/gh/JuliaPlots/Plots.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaPlots/Plots.jl)
 
-- [Qwt.jl](docs/qwt_examples.md)
-- [Gadfly.jl](docs/gadfly_examples.md)
-- [UnicodePlots.jl](docs/unicodeplots_examples.md)
-- [PyPlot.jl](docs/pyplot_examples.md)
-- [Immerse.jl](docs/immerse_examples.md)
-- [Winston.jl](docs/winston_examples.md)
+#### Created by Tom Breloff (@tbreloff)
 
-## Installation
-
-First, add the package
-
-```julia
-Pkg.add("Plots")
-```
-
-then get any plotting packages you need (obviously, you should get at least one backend):
-
-```julia
-Pkg.add("Gadfly")
-Pkg.add("Immerse")
-Pkg.add("UnicodePlots")
-Pkg.add("PyPlot")                                    # requires python and matplotlib
-Pkg.clone("https://github.com/tbreloff/Qwt.jl.git")  # requires pyqt and pyqwt
-Pkg.add("Winston")
-```
-
-## Use
-
-Load it in.  The underlying plotting backends are not imported until `plotter()` is called (which happens
-on your first call to `plot` or `subplot`).  This means that you don't need any backends to be installed when you call `using Plots`.
-Plots will try to figure out a good default backend for you automatically based on what backends are installed.
-
-```julia
-using Plots
-```
-
-Do a plot in Gadfly, then save a png:
-
-```julia
-# switch to Gadfly as a backend
-gadfly!()
-
-# This will bring up a browser window with the plot. Add a semicolon to skip display. 
-plot(rand(10,2); marker = :rect, markersizes=[10,30])
-
-# save it as a PNG
-savepng(Plots.IMG_DIR * "gadfly1.png")
-```
-
-which saves:
-
-![gadfly_plt](img/gadfly1.png)
-
-See the examples pages for lots of examples of plots, and what those commands produce for each supported backend.
-
-## API
-
-Call `plotter!(backend::Symbol)` or the shorthands (`gadfly!()`, `qwt!()`, `unicodeplots!()`, etc) to set the current plotting backend.
-Subsequent commands are converted into the relevant plotting commands for that package:
-
-```julia
-gadfly!()
-plot(1:10)    # this effectively calls `y = 1:10; Gadfly.plot(x=1:length(y), y=y)`
-qwt!()
-plot(1:10)    # this effectively calls `Qwt.plot(1:10)`
-```
-
-Use `plot` to create a new plot object, and `plot!` to add to an existing one:
-
-```julia
-plot(args...; kw...)                  # creates a new plot window, and sets it to be the `currentPlot`
-plot!(args...; kw...)                 # adds to the `currentPlot`
-plot!(plotobj, args...; kw...)        # adds to the plot `plotobj`
-```
-
-Now that you know which plot object you're updating (new, current, or other), I'll leave it off for simplicity.
-Here are some various args to supply, and the implicit mapping (AVec == AbstractVector and AMat == AbstractMatrix):
-
-```julia
-# one line... x = 1:length(y)
-plot(y::AVec; kw...)
-
-# one line (will assert length(x) == length(y))
-plot(x::AVec, y::AVec; kw...)
-
-# multiple lines (one per column of x), all sharing x = 1:size(y,1)
-plot(y::AMat; kw...)
-
-# multiple lines (one per column of x), all sharing x (will assert length(x) == size(y,1))
-plot(x::AVec, y::AMat; kw...)
-
-# multiple lines (one per column of x/y... will assert size(x) == size(y))
-plot(x::AMat, y::AMat; kw...)
-
-# one line, map function for range [xmin,xmax]
-plot(f::Function, xmin::Real, xmax::Real; kw...)
-
-# multiple lines, map functions for range [xmin,xmax]
-plot(f::AVec{Function}, xmin::Real, xmax::Real; kw...)
-
-# parametric plot... x = fx(u), y = fy(u)
-plot(fx::Function, fy::Function, umin::Real, umax::Real; kw...)
-
-# one line, y = f(x)... can swap x and f
-plot(x::AVec, f::Function; kw...)
-
-# multiple lines, yᵢⱼ = f(xᵢⱼ)... can swap f and x
-plot(x::AMat, f::Function; kw...)
-
-# multiple lines, yᵢⱼ = fⱼ(xᵢ)
-plot(x::AVec, fs::AVec{Function}; kw...)
-
-# multiple lines, each with x = 1:length(y[i])
-plot(y::AVec{AVec}; kw...)
-
-# multiple lines, will assert length(x) == length(y[i])
-plot(x::AVec, y::AVec{AVec}; kw...)
-
-# multiple lines, will assert length(x[i]) == length(y[i])
-plot(x::AVec{AVec}, y::AVec{AVec}; kw...)
-
-# n lines, all empty (for updating plots)
-plot(n::Integer; kw...)
-
-# TODO: DataFrames, categorical values
-```
-
-With `subplot`, create multiple plots at once, with flexible layout options:
-
-```julia
-y = rand(100,3)
-subplot(y; n = 3)             # create an automatic grid, and let it figure out the shape
-subplot(y; n = 3, nr = 1)     # create an automatic grid, but fix the number of rows
-subplot(y; n = 3, nc = 1)     # create an automatic grid, but fix the number of columns
-subplot(y; layout = [1, 2])   # explicit layout.  Lists the number of plots in each row
-```
-
-__Tip__: You can call `subplot!(args...; kw...)` to add to an existing subplot.
-
-__Tip__: Calling `subplot!` on a `Plot` object, or `plot!` on a `Subplot` object will throw an error.
-
-Shorthands:
-
-```julia
-scatter(args...; kw...)    = plot(args...; kw...,  linetype = :scatter)
-scatter!(args...; kw...)   = plot!(args...; kw..., linetype = :scatter)
-bar(args...; kw...)        = plot(args...; kw...,  linetype = :bar)
-bar!(args...; kw...)       = plot!(args...; kw..., linetype = :bar)
-histogram(args...; kw...)  = plot(args...; kw...,  linetype = :hist)
-histogram!(args...; kw...) = plot!(args...; kw..., linetype = :hist)
-heatmap(args...; kw...)    = plot(args...; kw...,  linetype = :heatmap)
-heatmap!(args...; kw...)   = plot!(args...; kw..., linetype = :heatmap)
-sticks(args...; kw...)     = plot(args...; kw...,  linetype = :sticks, marker = :ellipse)
-sticks!(args...; kw...)    = plot!(args...; kw..., linetype = :sticks, marker = :ellipse)
-```
-
-Some keyword arguments you can set:
-
-```
-axis            # :left or :right
-color           # can be a string ("red") or a symbol (:red) or a ColorsTypes.jl 
-                #   Colorant (RGB(1,0,0)) or :auto (which lets the package pick)
-label           # string or symbol, applies to that line, may go in a legend
-width           # width of a line
-linetype        # :line, :step, :stepinverted, :sticks, :scatter, :none, :heatmap, :hexbin, :hist, :bar
-linestyle       # :solid, :dash, :dot, :dashdot, :dashdotdot
-marker          # :none, :ellipse, :rect, :diamond, :utriangle, :dtriangle,
-                #   :cross, :xcross, :star1, :star2, :hexagon
-markercolor     # same choices as `color`, or :match will set the color to be the same as `color`
-markersize      # size of the marker
-nbins           # number of bins for heatmap/hexbin and histograms
-heatmap_c       # color cutoffs for Qwt heatmaps
-fillto          # fillto value for area plots
-title           # string or symbol, title of the plot
-xlabel          # string or symbol, label on the bottom (x) axis
-ylabel          # string or symbol, label on the left (y) axis
-yrightlabel     # string or symbol, label on the right (y) axis
-reg             # true or false, add a regression line for each line
-size            # (Int,Int), resize the enclosing window
-pos             # (Int,Int), move the enclosing window to this position
-windowtitle     # string or symbol, set the title of the enclosing windowtitle
-screen          # Integer, move enclosing window to this screen number (for multiscreen desktops)
-```
-
-Note that not every backend supports all options.
-
-If you don't include a keyword argument, these are the defaults:
-  
-```
-axis = :left
-color = :auto
-label = automatically generated (y1, y2, ...., or y1 (R), y2 (R) for the right axis)
-width = 1
-linetype = :line
-linestype = :solid
-marker = :none
-markercolor = :match
-markersize = 3
-nbins = 100
-heatmap_c = (0.15, 0.5)
-fillto = nothing
-title = ""
-xlabel = ""
-ylabel = ""
-yrightlabel = ""
-reg = false
-size = (600,400)
-pos = (0,0)
-windowtitle = "Plots.jl"
-screen = 1
-```
-
-__Tip__: You can see the default value for a given argument with `plotDefault(arg::Symbol)`, and set the default value with `plotDefault!(arg::Symbol, value)`
-
-__Tip__: When plotting multiple lines, you can give every line the same trait by using the singular, or add an "s" to pluralize.
-          (yes I know it's not gramatically correct, but it's easy to use and implement)
-
-```julia
-# Note: The same width is applied to both lines, whereas 
-#       each line gets different color and axis.
-plot(rand(100,2); colors = [:red, RGB(.5,.5,0)],
-                  axiss = [:left, :right],
-                  width = 5)
-```
-
-## TODO features:
-
-- [x] Plot vectors/matrices/functions
-- [ ] Plot DataFrames
-- [ ] Scales
-- [ ] Categorical Inputs (strings, etc... for hist, bar? or can split one series into multiple?)
-- [ ] Custom markers
-- [ ] Special plots (boxplot, ohlc?)
-- [x] Subplots
-- [x] Histograms
-- [ ] 3D plotting
-- [ ] Scenes/Drawing
-- [ ] Graphs
-- [ ] Interactivity (GUIs)
-
-## TODO backends:
-
-- [x] Gadfly.jl
-- [x] Immerse.jl
-- [x] PyPlot.jl
-- [x] UnicodePlots.jl
-- [x] Qwt.jl
-- [x] Winston.jl
-- [ ] GLPlot.jl
-- [ ] Bokeh.jl
-- [ ] Vega.jl
-- [ ] Gaston.jl
-- [ ] Plotly.jl
-- [ ] GoogleCharts.jl
-- [ ] PLplot.jl
-- [ ] TextPlots.jl
-- [ ] ASCIIPlots.jl
-- [ ] Sparklines.jl
-- [ ] Hinton.jl
-- [ ] ImageTerm.jl
-- [ ] GraphViz.jl
-- [ ] TikzGraphs.jl
-- [ ] GraphLayout.jl
-
-## More information on backends (both supported and unsupported)
-
-See the wiki at: https://github.com/JuliaPlot/juliaplot_docs/wiki
+#### Maintained by the [JuliaPlots members](https://github.com/orgs/JuliaPlots/people)
 
+Plots is a plotting API and toolset.  My goals with the package are:
 
+- **Powerful**.  Do more with less.  Complex visualizations become easy.
+- **Intuitive**.  Stop reading so much documentation.  Commands should "just work".
+- **Concise**.  Less code means fewer mistakes and more efficient development/analysis.
+- **Flexible**.  Produce your favorite plots from your favorite package, but quicker and simpler.
+- **Consistent**.  Don't commit to one graphics package, use the same code everywhere.
+- **Lightweight**.  Very few dependencies.
+- **Smart**. Attempts to figure out what you **want** it to do... not just what you **tell** it.

REQUIRE

@@ -1,3 +0,0 @@
-julia 0.4-
-
-Colors

appveyor.yml

@@ -1,34 +0,0 @@
-environment:
-  matrix:
-  - JULIAVERSION: "julialang/bin/winnt/x86/0.3/julia-0.3-latest-win32.exe"
-  - JULIAVERSION: "julialang/bin/winnt/x64/0.3/julia-0.3-latest-win64.exe"
-  - JULIAVERSION: "julianightlies/bin/winnt/x86/julia-latest-win32.exe"
-  - JULIAVERSION: "julianightlies/bin/winnt/x64/julia-latest-win64.exe"
-
-branches:
-  only:
-    - master
-    - /release-.*/
-
-notifications:
-  - provider: Email
-    on_build_success: false
-    on_build_failure: false
-    on_build_status_changed: false
-
-install:
-# Download most recent Julia Windows binary
-  - ps: (new-object net.webclient).DownloadFile(
-        $("http://s3.amazonaws.com/"+$env:JULIAVERSION),
-        "C:\projects\julia-binary.exe")
-# Run installer silently, output to C:\projects\julia
-  - C:\projects\julia-binary.exe /S /D=C:\projects\julia
-
-build_script:
-# Need to convert from shallow to complete for Pkg.clone to work
-  - IF EXIST .git\shallow (git fetch --unshallow)
-  - C:\projects\julia\bin\julia -e "versioninfo();
-      Pkg.clone(pwd(), \"Plots\"); Pkg.build(\"Plots\")"
-
-test_script:
-  - C:\projects\julia\bin\julia --check-bounds=yes -e "Pkg.test(\"Plots\")"

codecov.yml

@@ -0,0 +1,10 @@
+ignore:
+  - "src/backends/inspectdr.jl"
+  - "src/backends/orca.jl"
+  - "src/backends/pgfplots.jl"
+  - "src/backends/plotly.jl"
+  - "src/backends/plotlyjs.jl"
+  - "src/backends/pyplot.jl"
+  - "src/backends/web.jl"
+  - "src/fileio.jl"
+  - "src/ijulia.jl"

deps/SnoopCompile/precompile/linux/1.5/precompile_Plots.jl

@@ -0,0 +1,390 @@
+const __bodyfunction__ = Dict{Method,Any}()
+
+# Find keyword "body functions" (the function that contains the body
+# as written by the developer, called after all missing keyword-arguments
+# have been assigned values), in a manner that doesn't depend on
+# gensymmed names.
+# `mnokw` is the method that gets called when you invoke it without
+# supplying any keywords.
+function __lookup_kwbody__(mnokw::Method)
+    function getsym(arg)
+        isa(arg, Symbol) && return arg
+        @assert isa(arg, GlobalRef)
+        return arg.name
+    end
+
+    f = get(__bodyfunction__, mnokw, nothing)
+    if f === nothing
+        fmod = mnokw.module
+        # The lowered code for `mnokw` should look like
+        #   %1 = mkw(kwvalues..., #self#, args...)
+        #        return %1
+        # where `mkw` is the name of the "active" keyword body-function.
+        ast = Base.uncompressed_ast(mnokw)
+        if isa(ast, Core.CodeInfo) && length(ast.code) >= 2
+            callexpr = ast.code[end-1]
+            if isa(callexpr, Expr) && callexpr.head == :call
+                fsym = callexpr.args[1]
+                if isa(fsym, Symbol)
+                    f = getfield(fmod, fsym)
+                elseif isa(fsym, GlobalRef)
+                    if fsym.mod === Core && fsym.name === :_apply
+                        f = getfield(mnokw.module, getsym(callexpr.args[2]))
+                    elseif fsym.mod === Core && fsym.name === :_apply_iterate
+                        f = getfield(mnokw.module, getsym(callexpr.args[3]))
+                    else
+                        f = getfield(fsym.mod, fsym.name)
+                    end
+                else
+                    f = missing
+                end
+            else
+                f = missing
+            end
+        else
+            f = missing
+        end
+        __bodyfunction__[mnokw] = f
+    end
+    return f
+end
+
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:label, :blank),Tuple{Symbol,Bool}},Type{Plots.EmptyLayout}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:label, :width, :height),Tuple{Symbol,Symbol,Measures.Length{:pct,Float64}}},Type{Plots.EmptyLayout}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:parent,),Tuple{Plots.GridLayout}},Type{Plots.Subplot},Plots.GRBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:parent,),Tuple{Plots.GridLayout}},Type{Plots.Subplot},Plots.PlotlyBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:parent,),Tuple{Plots.Subplot{Plots.GRBackend}}},Type{Plots.Subplot},Plots.GRBackend})
+    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}},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{typeof(RecipesPipeline.datetimeformatter)}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:grid, :lims),Tuple{Bool,Tuple{Int64,Int64}}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:grid, :lims, :flip),Tuple{Bool,Tuple{Int64,Int64},Bool}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:grid,),Tuple{Bool}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid),Tuple{Int64,Bool,Float64,Symbol,RGBA{Float64}}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:guide,),Tuple{String}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:lims, :flip, :ticks, :guide),Tuple{Tuple{Int64,Int64},Bool,StepRange{Int64,Int64},String}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:lims,),Tuple{Tuple{Float64,Float64}}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:lims,),Tuple{Tuple{Int64,Float64}}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:lims,),Tuple{Tuple{Int64,Int64}}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:rotation,),Tuple{Int64}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:scale, :guide),Tuple{Symbol,String}},typeof(attr!),Plots.Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:ticks,),Tuple{UnitRange{Int64}}},typeof(attr!),Plots.Axis})
+    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{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.heatmap)),Any,typeof(heatmap),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.histogram)),Any,typeof(histogram),Any})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.hline!)),Any,typeof(hline!),Any})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.lens!)),Any,typeof(lens!),Any,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{(: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{(:lw, :color),Tuple{Int64,Symbol}},typeof(plot!),Function,Float64,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:lw, :color),Tuple{Int64,Symbol}},typeof(plot!),Plots.Plot{Plots.GRBackend},Function,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.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{(: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{(:title,),Tuple{String}},typeof(plot!)})
+    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{(: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{(: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{(:bins, :weights, :seriestype),Tuple{Symbol,Array{Int64,1},Symbol}},typeof(plot),Array{Float64,1}})
+    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}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:lab, :w, :palette, :fill, :α),Tuple{String,Int64,PlotUtils.ContinuousColorGradient,Int64,Float64}},typeof(plot),StepRange{Int64,Int64},Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend),Tuple{Array{String,2},String,String,Int64,Symbol}},typeof(plot),Array{Function,1},Float64,Vararg{Float64,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:label,),Tuple{Array{String,2}}},typeof(plot),Array{AbstractArray{Float64,1},1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :group, :linetype, :linecolor),Tuple{Plots.GridLayout,Array{String,1},Array{Symbol,2},Symbol}},typeof(plot),Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha),Tuple{Tuple{Int64,Int64},String,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, :label, :fillrange, :fillalpha),Tuple{Tuple{Int64,Int64},String,Int64,Float64}},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{(:layout, :link),Tuple{Int64,Symbol}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :link),Tuple{Int64,Symbol}},typeof(plot),Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}})
+    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{(: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}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:legend,),Tuple{Symbol}},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{Symbol}},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{(:line, :lab, :ms),Tuple{Tuple{Array{Symbol,2},Int64},Array{String,2},Int64}},typeof(plot),Array{Array{T,1} where T,1},Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:line, :label, :legendtitle),Tuple{Tuple{Int64,Array{Symbol,2}},Array{String,2},String}},typeof(plot),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:line, :leg, :fill),Tuple{Int64,Bool,Tuple{Int64,Symbol}}},typeof(plot),Function,Function,Vararg{Any,N} where N})
+    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{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{(:nbins, :show_empty_bins, :normed, :aspect_ratio, :seriestype),Tuple{Tuple{Int64,Int64},Bool,Bool,Int64,Symbol}},typeof(plot),Array{Complex{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{(:projection, :seriestype),Tuple{Symbol,Symbol}},typeof(plot),Array{Int64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:quiver, :seriestype),Tuple{Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}},Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:reg, :fill),Tuple{Bool,Tuple{Int64,Symbol}}},typeof(plot),Array{Float64,1}})
+    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),Array{OHLC,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel),Tuple{Symbol,String,String,String}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},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),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}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:xaxis, :background_color, :leg),Tuple{Tuple{String,Tuple{Int64,Int64},StepRange{Int64,Int64},Symbol},RGB{Float64},Bool}},typeof(plot),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:yflip, :aspect_ratio),Tuple{Bool,Symbol}},typeof(plot),Array{Float64,1},Array{Int64,1},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w),Tuple{StepRange{Int64,Int64},Tuple{Int64,Float64,Symbol,Plots.Stroke},Bool,Bool,Int64}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.scatter!)),Any,typeof(scatter!),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.scatter!)),Any,typeof(scatter!),Any})
+    Base.precompile(Tuple{Core.kwftype(typeof(Plots.test_examples)),NamedTuple{(:skip,),Tuple{Array{Int64,1}}},typeof(test_examples),Symbol})
+    Base.precompile(Tuple{Type{Plots.GridLayout},Int64,Vararg{Int64,N} where N})
+    Base.precompile(Tuple{Type{Shape},Array{Tuple{Float64,Float64},1}})
+    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.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.collect_similar),Array{AbstractLayout,1},Base.Generator{Array{AbstractLayout,1},typeof(Plots.leftpad)}})
+    Base.precompile(Tuple{typeof(Base.collect_similar),Array{AbstractLayout,2},Base.Generator{Array{AbstractLayout,2},typeof(Plots._update_min_padding!)}})
+    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._bin_centers),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
+    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._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),Base.OneTo{Int64},Array{Int64,1}})
+    Base.precompile(Tuple{typeof(Plots._cycle),StepRange{Int64,Int64},Array{Int64,1}})
+    Base.precompile(Tuple{typeof(Plots._do_plot_show),Plots.Plot{Plots.GRBackend},Bool})
+    Base.precompile(Tuple{typeof(Plots._do_plot_show),Plots.Plot{Plots.PlotlyBackend},Bool})
+    Base.precompile(Tuple{typeof(Plots._heatmap_edges),Array{Float64,1},Bool})
+    Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot,Any,Any})
+    Base.precompile(Tuple{typeof(Plots._preprocess_barlike),RecipesPipeline.DefaultsDict,Base.OneTo{Int64},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(Plots._preprocess_binlike),RecipesPipeline.DefaultsDict,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(Plots._replace_markershape),Array{Symbol,1}})
+    Base.precompile(Tuple{typeof(Plots._update_min_padding!),Plots.GridLayout})
+    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.build_layout),Plots.GridLayout,Int64})
+    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.error_coords),Array{Float64,1},Array{Float64,1},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(Plots.error_zipit),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}})
+    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_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_xy),Array{OHLC,1}})
+    Base.precompile(Tuple{typeof(Plots.gr_add_legend),Plots.Subplot{Plots.GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),NTuple{9,Float64}},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(Plots.gr_add_legend),Plots.Subplot{Plots.GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),Tuple{Int64,Float64,Float64,Float64,Int64,Float64,Float64,Float64,Float64}},Array{Float64,1}})
+    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_contour),Plots.Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(Plots.gr_draw_grid),Plots.Subplot{Plots.GRBackend},Plots.Axis,Segments{Tuple{Float64,Float64}}})
+    Base.precompile(Tuple{typeof(Plots.gr_draw_heatmap),Plots.Series,Array{Float64,1},Array{Float64,1},Array{Float64,2},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(Plots.gr_draw_heatmap),Plots.Series,Base.OneTo{Int64},Base.OneTo{Int64},Array{Float64,2},Tuple{Float64,Float64}})
+    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,Base.OneTo{Int64},Array{Float64,1},Tuple{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}})
+    Base.precompile(Tuple{typeof(Plots.gr_draw_segments),Plots.Series,Array{Float64,1},Array{Float64,1},Int64,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(Plots.gr_draw_segments),Plots.Series,Base.OneTo{Int64},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(Plots.gr_draw_segments),Plots.Series,StepRange{Int64,Int64},Array{Float64,1},Int64,Tuple{Float64,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_label_ticks),Plots.Subplot{Plots.GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
+    Base.precompile(Tuple{typeof(Plots.gr_label_ticks_3d),Plots.Subplot{Plots.GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
+    Base.precompile(Tuple{typeof(Plots.gr_polaraxes),Int64,Float64,Plots.Subplot{Plots.GRBackend}})
+    Base.precompile(Tuple{typeof(Plots.gr_set_gradient),PlotUtils.ContinuousColorGradient})
+    Base.precompile(Tuple{typeof(Plots.heatmap_edges),Array{Float64,1},Symbol})
+    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})
+    Base.precompile(Tuple{typeof(Plots.heatmap_edges),UnitRange{Int64},Symbol})
+    Base.precompile(Tuple{typeof(Plots.ignorenan_extrema),StepRange{Int64,Int64}})
+    Base.precompile(Tuple{typeof(Plots.ignorenan_minimum),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(Plots.is_marker_supported),Plots.PlotlyBackend,Array{Symbol,1}})
+    Base.precompile(Tuple{typeof(Plots.layout_args),Int64})
+    Base.precompile(Tuple{typeof(Plots.make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
+    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.processFontArg!),Dict{Symbol,Any},Symbol,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},Symbol})
+    Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Array{Symbol,2}})
+    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.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},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(Plots.process_axis_arg!),Dict{Symbol,Any},Tuple{Int64,Int64},Symbol})
+    Base.precompile(Tuple{typeof(Plots.quiver_using_arrows),RecipesPipeline.DefaultsDict})
+    Base.precompile(Tuple{typeof(Plots.quiver_using_hack),RecipesPipeline.DefaultsDict})
+    Base.precompile(Tuple{typeof(Plots.reset_axis_defaults_byletter!)})
+    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.straightline_data),Tuple{Float64,Float64},Tuple{Float64,Float64},Array{Float64,1},Array{Float64,1},Int64})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},AbstractArray{OHLC,1}})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Array{Complex{Float64},1}})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Plots.PortfolioComposition})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:barhist}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:bar}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:histogram2d}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:hline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:pie}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:quiver}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:spy}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:sticks}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:xerror}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesPipeline._finish_userrecipe!),Plots.Plot{Plots.GRBackend},Array{Dict{Symbol,Any},1},RecipeData})
+    Base.precompile(Tuple{typeof(RecipesPipeline._finish_userrecipe!),Plots.Plot{Plots.PlotlyBackend},Array{Dict{Symbol,Any},1},RecipeData})
+    Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plots.Plot{Plots.GRBackend},RecipesPipeline.DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plots.Plot{Plots.PlotlyBackend},RecipesPipeline.DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plots.Plot{Plots.GRBackend},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.unzip),Array{GeometryBasics.Point{2,Float64},1}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,String})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Symbol,String})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},RecipesPipeline.DefaultsDict,Symbol,String})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,String})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Symbol,String})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},RecipesPipeline.DefaultsDict,Symbol,String})
+    Base.precompile(Tuple{typeof(backend),Plots.PlotlyBackend})
+    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),Any,Vararg{Any,N} where N})
+    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_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{2},Tuple{Base.OneTo{Int64},Base.OneTo{Int64}},typeof(Plots.gr_color),Tuple{Array{RGBA{Float64},2}}}})
+    Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple},Nothing,typeof(string),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple},Nothing,typeof(typeof),Tuple{Tuple{Plots.PortfolioComposition}}}}}})
+    Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple},Nothing,typeof(string),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple},Nothing,typeof(typeof),Tuple{Tuple{Plots.Spy}}}}}})
+    Base.precompile(Tuple{typeof(deepcopy),Plots.Plot{Plots.PlotlyBackend}})
+    Base.precompile(Tuple{typeof(font),String,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),Base.OneTo{Int64},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(merge),NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,Plots.PlotText},1}}},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}})
+    Base.precompile(Tuple{typeof(merge),NamedTuple{(:zcolor, :m, :ms, :lab),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String}},NamedTuple{(:seriestype,),Tuple{Symbol}}})
+    Base.precompile(Tuple{typeof(pairs),NamedTuple{(:zcolor, :m, :ms, :lab),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String}}})
+    Base.precompile(Tuple{typeof(plot!),Any})
+    Base.precompile(Tuple{typeof(plot),Any,Any})
+    Base.precompile(Tuple{typeof(plot),Any})
+    Base.precompile(Tuple{typeof(push!),Plots.Plot{Plots.GRBackend},Float64,Array{Float64,1}})
+    Base.precompile(Tuple{typeof(spy),Any})
+    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})
+    Base.precompile(Tuple{typeof(text),String,Symbol})
+    Base.precompile(Tuple{typeof(title!),AbstractString})
+    Base.precompile(Tuple{typeof(vcat),Array{Any,1},Array{Tuple{Int64,Float64,Plots.PlotText},1}})
+    Base.precompile(Tuple{typeof(vcat),Array{Any,1},Tuple{Int64,Float64,Plots.PlotText}})
+    Base.precompile(Tuple{typeof(vline!),Any})
+    Base.precompile(Tuple{typeof(xgrid!),Plots.Plot{Plots.GRBackend},Symbol,Vararg{Any,N} where N})
+    Base.precompile(Tuple{typeof(yaxis!),Any,Any})
+    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,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(Plots.text, (String,Symbol,Vararg{Any,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(text),String,Symbol,Vararg{Any,N} where N,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(Plots.title!, (AbstractString,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(title!),AbstractString,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(Plots.vline!, (Any,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(vline!),Any,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(Plots.yaxis!, (Any,Vararg{Any,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any,N} where N,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(RecipesBase.plot!, ())) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot!),))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(RecipesBase.plot!, (Any,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot!),Any,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(RecipesBase.plot!, (Any,Vararg{Any,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot!),Any,Vararg{Any,N} where N,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Any,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot),Any,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Any,Vararg{Any,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot),Any,Vararg{Any,N} where N,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Plots.Plot,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot),Plots.Plot,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Plots.Plot,Plots.Plot,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot),Plots.Plot,Plots.Plot,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Plots.Plot,Plots.Plot,Vararg{Plots.Plot,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot),Plots.Plot,Plots.Plot,Vararg{Plots.Plot,N} where N,))
+        end
+    end
+end

deps/SnoopCompile/precompile_script.jl

@@ -0,0 +1,4 @@
+using Plots
+
+Plots.test_examples(:gr, skip = Plots._backend_skips[:gr])
+Plots.test_examples(:plotly, skip = Plots._backend_skips[:plotly], disp = false)

deps/SnoopCompile/snoop_bench.jl

@@ -0,0 +1,11 @@
+using CompileBot
+
+snoop_bench(
+    BotConfig(
+        "Plots",
+        yml_path= "SnoopCompile.yml",
+        else_os = "linux",
+        else_version = "1.5",
+    ),
+    joinpath(@__DIR__, "precompile_script.jl"),
+)

deps/SnoopCompile/snoop_bot.jl

@@ -0,0 +1,11 @@
+using CompileBot
+
+snoop_bot(
+    BotConfig(
+        "Plots",
+        yml_path= "SnoopCompile.yml",
+        else_os = "linux",
+        else_version = "1.5",
+    ),
+    joinpath(@__DIR__, "precompile_script.jl"),
+)

docs/example_generation.jl

@@ -1,195 +0,0 @@
-
-module PlotExamples
-
-using Plots
-using Colors
-
-const DOCDIR = Pkg.dir("Plots") * "/docs"
-const IMGDIR = Pkg.dir("Plots") * "/img"
-
-doc"""
-Holds all data needed for a documentation example... header, description, and plotting expression (Expr)
-"""
-type PlotExample
-  header::String
-  desc::String
-  exprs::Vector{Expr}
-end
-
-
-# the examples we'll run for each
-const examples = PlotExample[
-  PlotExample("Lines",
-              "A simple line plot of the 3 columns.",
-              [:(plot(rand(100,3)))]),
-  PlotExample("Functions",
-              "Plot multiple functions.  You can also put the function first.",
-              [:(plot(0:0.01:4π, [sin,cos]))]),
-  PlotExample("",
-              "You can also call it with plot(f, xmin, xmax).",
-              [:(plot([sin,cos], 0, 4π))]),
-  PlotExample("",
-              "Or make a parametric plot (i.e. plot: (fx(u), fy(u))) with plot(fx, fy, umin, umax).",
-              [:(plot(sin, x->sin(2x), 0, 2π))]),
-  PlotExample("Global",
-              "Change the guides/background without a separate call.",
-              [:(plot(rand(10); title="TITLE", xlabel="XLABEL", ylabel="YLABEL", background_color = RGB(0.5,0.5,0.5)))]),
-  PlotExample("Two-axis",
-              "Use the `axis` or `axiss` arguments.\n\nNote: Currently only supported with Qwt and PyPlot",
-              [:(plot(Vector[randn(100), randn(100)*100]; axiss = [:left,:right], ylabel="LEFT", yrightlabel="RIGHT"))]),
-  PlotExample("Vectors w/ pluralized args",
-              "Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).",
-              [:(plot(Vector[rand(10), rand(20)]; marker=:ellipse, markersize=8, colors=[:red,:blue]))]),
-  PlotExample("Build plot in pieces",
-              "Start with a base plot...",
-              [:(plot(rand(100)/3; reg=true, fillto=0))]),
-  PlotExample("",
-              "and add to it later.",
-              [:(scatter!(rand(100); markersize=6, color=:blue))]),
-  PlotExample("Heatmaps",
-              "",
-              [:(heatmap(randn(10000),randn(10000); nbins=100))]),
-  PlotExample("Suported line types",
-              "All options: (:line, :orderedline, :step, :stepinverted, :sticks, :scatter, :none, :heatmap, :hexbin, :hist, :bar)",
-              [:(types = intersect(supportedTypes(), [:line, :step, :stepinverted, :sticks, :scatter])),
-                  :(n = length(types)),
-                  :(x = Vector[sort(rand(20)) for i in 1:n]),
-                  :(y = rand(20,n)),
-                  :(plot(x, y; linetypes=types, labels=map(string,types)))]),
-  PlotExample("Supported line styles",
-              "All options: (:solid, :dash, :dot, :dashdot, :dashdotdot)",
-              [:(styles = setdiff(supportedStyles(), [:auto])), :(plot(rand(20,length(styles)); linestyle=:auto, labels=map(string,styles)))]),
-  PlotExample("Supported marker types",
-              "All options: (:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon)",
-              [:(markers = setdiff(supportedMarkers(), [:none,:auto])), :(plot([fill(i,10) for i=1:length(markers)]; marker=:auto, labels=map(string,markers), markersize=10))]),
-  PlotExample("Bar",
-              "x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)",
-              [:(bar(randn(1000)))]),
-  PlotExample("Histogram",
-              "note: fillto isn't supported on all backends",
-              [:(histogram(randn(1000); nbins=50, fillto=20))]),
-  PlotExample("Subplots",
-              """
-                subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-                You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-                number of columns `nc`), or you can set the layout directly with `layout`.  
-
-                Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-              """,
-              [:(subplot(randn(100,5); layout=[1,1,3], linetypes=[:line,:hist,:scatter,:step,:bar], nbins=10, legend=false))]),
-  PlotExample("Adding to subplots",
-              "Note here the automatic grid layout, as well as the order in which new series are added to the plots.",
-              [:(subplot(randn(100,5); n=4))]),
-  PlotExample("",
-              "",
-              [:(subplot!(randn(100,3)))]),
-
-  
-]
-
-
-function createStringOfMarkDownCodeValues(arr, prefix = "")
-  string("`", prefix, join(arr, "`, `$prefix"), "`")
-end
-createStringOfMarkDownSymbols(arr) = createStringOfMarkDownCodeValues(arr, ":")
-
-
-function generate_markdown(pkgname::Symbol)
-
-  # set up the plotter, and don't show the plots by default
-  pkg = plotter!(pkgname)
-  # plotDefault!(:show, false)
-
-  # mkdir if necessary
-  try
-    mkdir("$IMGDIR/$pkgname")
-  end
-
-  # open the markdown file
-  md = open("$DOCDIR/$(pkgname)_examples.md", "w")
-
-  write(md, "# Examples for backend: $pkgname\n\n")
-  write(md, "- Supported arguments: $(createStringOfMarkDownCodeValues(supportedArgs(pkg)))\n")
-  write(md, "- Supported values for axis: $(createStringOfMarkDownSymbols(supportedAxes(pkg)))\n")
-  write(md, "- Supported values for linetype: $(createStringOfMarkDownSymbols(supportedTypes(pkg)))\n")
-  write(md, "- Supported values for linestyle: $(createStringOfMarkDownSymbols(supportedStyles(pkg)))\n")
-  write(md, "- Supported values for marker: $(createStringOfMarkDownSymbols(supportedMarkers(pkg)))\n")
-  write(md, "- Is `subplot`/`subplot!` supported? $(subplotSupported(pkg) ? "Yes" : "No")\n\n")
-
-  write(md, "### Initialize\n\n```julia\nusing Plots\n$(pkgname)!()\n```\n\n")
-
-
-  for (i,example) in enumerate(examples)
-
-    try
-
-      # run the code
-      map(eval, example.exprs)
-
-      # save the png
-      imgname = "$(pkgname)_example_$i.png"
-
-      # NOTE: uncomment this to overwrite the images as well
-      # savepng("$IMGDIR/$pkgname/$imgname")
-
-      # write out the header, description, code block, and image link
-      write(md, "### $(example.header)\n\n")
-      write(md, "$(example.desc)\n\n")
-      write(md, "```julia\n$(join(map(string, example.exprs), "\n"))\n```\n\n")
-      write(md, "![](../img/$pkgname/$imgname)\n\n")
-
-    catch ex
-      # TODO: put error info into markdown?
-      warn("Example $pkgname:$i failed with: $ex")
-    end
-
-    #
-  end
-
-  close(md)
-
-end
-
-
-# make and display one plot
-function test_example(pkgname::Symbol, idx::Int)
-  println("Testing plot: $pkgname:$idx:$(examples[idx].header)")
-  plotter!(pkgname)
-  plotter()
-  map(eval, examples[idx].exprs)
-  plt = currentPlot()
-  display(plt)
-  plt
-end
-
-# generate all plots and create a dict mapping idx --> plt
-function test_all_examples(pkgname::Symbol)
-  plts = Dict()
-  for i in 1:length(examples)
-    if examples[i].header == "Subplots" && !subplotSupported()
-      break
-    end
-
-    try
-      plt = test_example(pkgname, i)
-      plts[i] = plt
-    catch ex
-      # TODO: put error info into markdown?
-      warn("Example $pkgname:$i:$(examples[i].header) failed with: $ex")
-    end
-  end
-  plts
-end
-
-# run it!
-# note: generate separately so it's easy to comment out
-# @osx_only generate_markdown(:unicodeplots)
-# generate_markdown(:qwt)
-# generate_markdown(:gadfly)
-# generate_markdown(:pyplot)
-# generate_markdown(:immerse)
-# generate_markdown(:winston)
-
-
-end # module
-

docs/gadfly_examples.md

@@ -1,211 +0,0 @@
-# Examples for backend: gadfly
-
-- Supported arguments: `args`, `axis`, `color`, `kwargs`, `label`, `legend`, `linestyle`, `linetype`, `marker`, `markercolor`, `markersize`, `nbins`, `reg`, `size`, `title`, `width`, `windowtitle`, `xlabel`, `ylabel`, `yrightlabel`
-- Supported values for axis: `:auto`, `:left`
-- Supported values for linetype: `:line`, `:step`, `:sticks`, `:scatter`, `:heatmap`, `:hexbin`, `:hist`, `:bar`
-- Supported values for linestyle: `:auto`, `:solid`
-- Supported values for marker: `:none`, `:auto`, `:rect`, `:ellipse`, `:diamond`, `:cross`
-- Is `subplot`/`subplot!` supported? Yes
-
-### Initialize
-
-```julia
-using Plots
-gadfly!()
-```
-
-### Lines
-
-A simple line plot of the 3 columns.
-
-```julia
-plot(rand(100,3))
-```
-
-![](../img/gadfly/gadfly_example_1.png)
-
-### Functions
-
-Plot multiple functions.  You can also put the function first.
-
-```julia
-plot(0:0.01:4π,[sin,cos])
-```
-
-![](../img/gadfly/gadfly_example_2.png)
-
-### 
-
-You can also call it with plot(f, xmin, xmax).
-
-```julia
-plot([sin,cos],0,4π)
-```
-
-![](../img/gadfly/gadfly_example_3.png)
-
-### 
-
-Or make a parametric plot (i.e. plot: (fx(u), fy(u))) with plot(fx, fy, umin, umax).
-
-```julia
-plot(sin,(x->begin  # /home/tom/.julia/v0.4/Plots/docs/example_generation.jl, line 33:
-            sin(2x)
-        end),0,2π)
-```
-
-![](../img/gadfly/gadfly_example_4.png)
-
-### Global
-
-Change the guides/background without a separate call.
-
-```julia
-plot(rand(10); title="TITLE",xlabel="XLABEL",ylabel="YLABEL",background_color=RGB(0.5,0.5,0.5))
-```
-
-![](../img/gadfly/gadfly_example_5.png)
-
-### Two-axis
-
-Use the `axis` or `axiss` arguments.
-
-Note: Currently only supported with Qwt and PyPlot
-
-```julia
-plot(Vector[randn(100),randn(100) * 100]; axiss=[:left,:right],ylabel="LEFT",yrightlabel="RIGHT")
-```
-
-![](../img/gadfly/gadfly_example_6.png)
-
-### Vectors w/ pluralized args
-
-Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).
-
-```julia
-plot(Vector[rand(10),rand(20)]; marker=:ellipse,markersize=8,colors=[:red,:blue])
-```
-
-![](../img/gadfly/gadfly_example_7.png)
-
-### Build plot in pieces
-
-Start with a base plot...
-
-```julia
-plot(rand(100) / 3; reg=true,fillto=0)
-```
-
-![](../img/gadfly/gadfly_example_8.png)
-
-### 
-
-and add to it later.
-
-```julia
-scatter!(rand(100); markersize=6,color=:blue)
-```
-
-![](../img/gadfly/gadfly_example_9.png)
-
-### Heatmaps
-
-
-
-```julia
-heatmap(randn(10000),randn(10000); nbins=100)
-```
-
-![](../img/gadfly/gadfly_example_10.png)
-
-### Suported line types
-
-All options: (:line, :orderedline, :step, :stepinverted, :sticks, :scatter, :none, :heatmap, :hexbin, :hist, :bar)
-
-```julia
-types = intersect(supportedTypes(),[:line,:step,:stepinverted,:sticks,:scatter])
-n = length(types)
-x = Vector[sort(rand(20)) for i = 1:n]
-y = rand(20,n)
-plot(x,y; linetypes=types,labels=map(string,types))
-```
-
-![](../img/gadfly/gadfly_example_11.png)
-
-### Supported line styles
-
-All options: (:solid, :dash, :dot, :dashdot, :dashdotdot)
-
-```julia
-styles = setdiff(supportedStyles(),[:auto])
-plot(rand(20,length(styles)); linestyle=:auto,labels=map(string,styles))
-```
-
-![](../img/gadfly/gadfly_example_12.png)
-
-### Supported marker types
-
-All options: (:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon)
-
-```julia
-markers = setdiff(supportedMarkers(),[:none,:auto])
-plot([fill(i,10) for i = 1:length(markers)]; marker=:auto,labels=map(string,markers),markersize=10)
-```
-
-![](../img/gadfly/gadfly_example_13.png)
-
-### Bar
-
-x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)
-
-```julia
-bar(randn(1000))
-```
-
-![](../img/gadfly/gadfly_example_14.png)
-
-### Histogram
-
-note: fillto isn't supported on all backends
-
-```julia
-histogram(randn(1000); nbins=50,fillto=20)
-```
-
-![](../img/gadfly/gadfly_example_15.png)
-
-### Subplots
-
-  subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-  You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-  number of columns `nc`), or you can set the layout directly with `layout`.  
-
-  Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-
-
-```julia
-subplot(randn(100,5); layout=[1,1,3],linetypes=[:line,:hist,:scatter,:step,:bar],nbins=10,legend=false)
-```
-
-![](../img/gadfly/gadfly_example_16.png)
-
-### Adding to subplots
-
-Note here the automatic grid layout, as well as the order in which new series are added to the plots.
-
-```julia
-subplot(randn(100,5); n=4)
-```
-
-![](../img/gadfly/gadfly_example_17.png)
-
-### 
-
-
-
-```julia
-subplot!(randn(100,3))
-```
-
-![](../img/gadfly/gadfly_example_18.png)
-

docs/immerse_examples.md

@@ -1,211 +0,0 @@
-# Examples for backend: immerse
-
-- Supported arguments: `args`, `axis`, `color`, `kwargs`, `label`, `legend`, `linestyle`, `linetype`, `marker`, `markercolor`, `markersize`, `nbins`, `reg`, `size`, `title`, `width`, `windowtitle`, `xlabel`, `ylabel`, `yrightlabel`
-- Supported values for axis: `:auto`, `:left`
-- Supported values for linetype: `:line`, `:step`, `:sticks`, `:scatter`, `:heatmap`, `:hexbin`, `:hist`, `:bar`
-- Supported values for linestyle: `:auto`, `:solid`
-- Supported values for marker: `:none`, `:auto`, `:rect`, `:ellipse`, `:diamond`, `:cross`
-- Is `subplot`/`subplot!` supported? Yes
-
-### Initialize
-
-```julia
-using Plots
-immerse!()
-```
-
-### Lines
-
-A simple line plot of the 3 columns.
-
-```julia
-plot(rand(100,3))
-```
-
-![](../img/immerse/immerse_example_1.png)
-
-### Functions
-
-Plot multiple functions.  You can also put the function first.
-
-```julia
-plot(0:0.01:4π,[sin,cos])
-```
-
-![](../img/immerse/immerse_example_2.png)
-
-### 
-
-You can also call it with plot(f, xmin, xmax).
-
-```julia
-plot([sin,cos],0,4π)
-```
-
-![](../img/immerse/immerse_example_3.png)
-
-### 
-
-Or make a parametric plot (i.e. plot: (fx(u), fy(u))) with plot(fx, fy, umin, umax).
-
-```julia
-plot(sin,(x->begin  # /home/tom/.julia/v0.4/Plots/docs/example_generation.jl, line 33:
-            sin(2x)
-        end),0,2π)
-```
-
-![](../img/immerse/immerse_example_4.png)
-
-### Global
-
-Change the guides/background without a separate call.
-
-```julia
-plot(rand(10); title="TITLE",xlabel="XLABEL",ylabel="YLABEL",background_color=RGB(0.5,0.5,0.5))
-```
-
-![](../img/immerse/immerse_example_5.png)
-
-### Two-axis
-
-Use the `axis` or `axiss` arguments.
-
-Note: Currently only supported with Qwt and PyPlot
-
-```julia
-plot(Vector[randn(100),randn(100) * 100]; axiss=[:left,:right],ylabel="LEFT",yrightlabel="RIGHT")
-```
-
-![](../img/immerse/immerse_example_6.png)
-
-### Vectors w/ pluralized args
-
-Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).
-
-```julia
-plot(Vector[rand(10),rand(20)]; marker=:ellipse,markersize=8,colors=[:red,:blue])
-```
-
-![](../img/immerse/immerse_example_7.png)
-
-### Build plot in pieces
-
-Start with a base plot...
-
-```julia
-plot(rand(100) / 3; reg=true,fillto=0)
-```
-
-![](../img/immerse/immerse_example_8.png)
-
-### 
-
-and add to it later.
-
-```julia
-scatter!(rand(100); markersize=6,color=:blue)
-```
-
-![](../img/immerse/immerse_example_9.png)
-
-### Heatmaps
-
-
-
-```julia
-heatmap(randn(10000),randn(10000); nbins=100)
-```
-
-![](../img/immerse/immerse_example_10.png)
-
-### Suported line types
-
-All options: (:line, :orderedline, :step, :stepinverted, :sticks, :scatter, :none, :heatmap, :hexbin, :hist, :bar)
-
-```julia
-types = intersect(supportedTypes(),[:line,:step,:stepinverted,:sticks,:scatter])
-n = length(types)
-x = Vector[sort(rand(20)) for i = 1:n]
-y = rand(20,n)
-plot(x,y; linetypes=types,labels=map(string,types))
-```
-
-![](../img/immerse/immerse_example_11.png)
-
-### Supported line styles
-
-All options: (:solid, :dash, :dot, :dashdot, :dashdotdot)
-
-```julia
-styles = setdiff(supportedStyles(),[:auto])
-plot(rand(20,length(styles)); linestyle=:auto,labels=map(string,styles))
-```
-
-![](../img/immerse/immerse_example_12.png)
-
-### Supported marker types
-
-All options: (:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon)
-
-```julia
-markers = setdiff(supportedMarkers(),[:none,:auto])
-plot([fill(i,10) for i = 1:length(markers)]; marker=:auto,labels=map(string,markers),markersize=10)
-```
-
-![](../img/immerse/immerse_example_13.png)
-
-### Bar
-
-x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)
-
-```julia
-bar(randn(1000))
-```
-
-![](../img/immerse/immerse_example_14.png)
-
-### Histogram
-
-note: fillto isn't supported on all backends
-
-```julia
-histogram(randn(1000); nbins=50,fillto=20)
-```
-
-![](../img/immerse/immerse_example_15.png)
-
-### Subplots
-
-  subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-  You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-  number of columns `nc`), or you can set the layout directly with `layout`.  
-
-  Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-
-
-```julia
-subplot(randn(100,5); layout=[1,1,3],linetypes=[:line,:hist,:scatter,:step,:bar],nbins=10,legend=false)
-```
-
-![](../img/immerse/immerse_example_16.png)
-
-### Adding to subplots
-
-Note here the automatic grid layout, as well as the order in which new series are added to the plots.
-
-```julia
-subplot(randn(100,5); n=4)
-```
-
-![](../img/immerse/immerse_example_17.png)
-
-### 
-
-
-
-```julia
-subplot!(randn(100,3))
-```
-
-![](../img/immerse/immerse_example_18.png)
-

docs/pyplot_examples.md

@@ -1,176 +0,0 @@
-# Examples for backend: pyplot
-
-- Supported arguments: `args`, `axis`, `color`, `kwargs`, `label`, `legend`, `linestyle`, `linetype`, `marker`, `markercolor`, `markersize`, `nbins`, `size`, `title`, `width`, `windowtitle`, `xlabel`, `ylabel`, `yrightlabel`
-- Supported values for axis: `:auto`, `:left`, `:right`
-- Supported values for linetype: `:none`, `:line`, `:step`, `:stepinverted`, `:sticks`, `:scatter`, `:heatmap`, `:hexbin`, `:hist`, `:bar`
-- Supported values for linestyle: `:auto`, `:solid`, `:dash`, `:dot`, `:dashdot`
-- Supported values for marker: `:none`, `:auto`, `:ellipse`, `:rect`, `:diamond`, `:utriangle`, `:dtriangle`, `:cross`, `:xcross`, `:star1`, `:hexagon`
-- Is `subplot`/`subplot!` supported? No
-
-### Initialize
-
-```julia
-using Plots
-pyplot!()
-```
-
-### Lines
-
-A simple line plot of the 3 columns.
-
-```julia
-plot(rand(100,3))
-```
-
-![](../img/pyplot/pyplot_example_1.png)
-
-### Functions
-
-Plot multiple functions.  You can also put the function first.
-
-```julia
-plot(0:0.01:4π,[sin,cos])
-```
-
-![](../img/pyplot/pyplot_example_2.png)
-
-### 
-
-You can also call it with plot(f, xmin, xmax).
-
-```julia
-plot([sin,cos],0,4π)
-```
-
-![](../img/pyplot/pyplot_example_3.png)
-
-### 
-
-Or make a parametric plot (i.e. plot: (fx(u), fy(u))) with plot(fx, fy, umin, umax).
-
-```julia
-plot(sin,(x->begin  # /home/tom/.julia/v0.4/Plots/docs/example_generation.jl, line 33:
-            sin(2x)
-        end),0,2π)
-```
-
-![](../img/pyplot/pyplot_example_4.png)
-
-### Global
-
-Change the guides/background without a separate call.
-
-```julia
-plot(rand(10); title="TITLE",xlabel="XLABEL",ylabel="YLABEL",background_color=RGB(0.5,0.5,0.5))
-```
-
-![](../img/pyplot/pyplot_example_5.png)
-
-### Two-axis
-
-Use the `axis` or `axiss` arguments.
-
-Note: Currently only supported with Qwt and PyPlot
-
-```julia
-plot(Vector[randn(100),randn(100) * 100]; axiss=[:left,:right],ylabel="LEFT",yrightlabel="RIGHT")
-```
-
-![](../img/pyplot/pyplot_example_6.png)
-
-### Vectors w/ pluralized args
-
-Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).
-
-```julia
-plot(Vector[rand(10),rand(20)]; marker=:ellipse,markersize=8,colors=[:red,:blue])
-```
-
-![](../img/pyplot/pyplot_example_7.png)
-
-### Build plot in pieces
-
-Start with a base plot...
-
-```julia
-plot(rand(100) / 3; reg=true,fillto=0)
-```
-
-![](../img/pyplot/pyplot_example_8.png)
-
-### 
-
-and add to it later.
-
-```julia
-scatter!(rand(100); markersize=6,color=:blue)
-```
-
-![](../img/pyplot/pyplot_example_9.png)
-
-### Heatmaps
-
-
-
-```julia
-heatmap(randn(10000),randn(10000); nbins=100)
-```
-
-![](../img/pyplot/pyplot_example_10.png)
-
-### Suported line types
-
-All options: (:line, :orderedline, :step, :stepinverted, :sticks, :scatter, :none, :heatmap, :hexbin, :hist, :bar)
-
-```julia
-types = intersect(supportedTypes(),[:line,:step,:stepinverted,:sticks,:scatter])
-n = length(types)
-x = Vector[sort(rand(20)) for i = 1:n]
-y = rand(20,n)
-plot(x,y; linetypes=types,labels=map(string,types))
-```
-
-![](../img/pyplot/pyplot_example_11.png)
-
-### Supported line styles
-
-All options: (:solid, :dash, :dot, :dashdot, :dashdotdot)
-
-```julia
-styles = setdiff(supportedStyles(),[:auto])
-plot(rand(20,length(styles)); linestyle=:auto,labels=map(string,styles))
-```
-
-![](../img/pyplot/pyplot_example_12.png)
-
-### Supported marker types
-
-All options: (:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon)
-
-```julia
-markers = setdiff(supportedMarkers(),[:none,:auto])
-plot([fill(i,10) for i = 1:length(markers)]; marker=:auto,labels=map(string,markers),markersize=10)
-```
-
-![](../img/pyplot/pyplot_example_13.png)
-
-### Bar
-
-x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)
-
-```julia
-bar(randn(1000))
-```
-
-![](../img/pyplot/pyplot_example_14.png)
-
-### Histogram
-
-note: fillto isn't supported on all backends
-
-```julia
-histogram(randn(1000); nbins=50,fillto=20)
-```
-
-![](../img/pyplot/pyplot_example_15.png)
-

docs/qwt_examples.md

@@ -1,211 +0,0 @@
-# Examples for backend: qwt
-
-- Supported arguments: `args`, `axis`, `color`, `fillto`, `heatmap_c`, `kwargs`, `label`, `legend`, `linestyle`, `linetype`, `marker`, `markercolor`, `markersize`, `nbins`, `reg`, `size`, `title`, `width`, `windowtitle`, `xlabel`, `ylabel`, `yrightlabel`
-- Supported values for axis: `:auto`, `:left`, `:right`
-- Supported values for linetype: `:none`, `:line`, `:step`, `:stepinverted`, `:sticks`, `:scatter`, `:heatmap`, `:hexbin`, `:hist`, `:bar`
-- Supported values for linestyle: `:auto`, `:solid`, `:dash`, `:dot`, `:dashdot`, `:dashdotdot`
-- Supported values for marker: `:none`, `:auto`, `:ellipse`, `:rect`, `:diamond`, `:utriangle`, `:dtriangle`, `:cross`, `:xcross`, `:star1`, `:star2`, `:hexagon`
-- Is `subplot`/`subplot!` supported? Yes
-
-### Initialize
-
-```julia
-using Plots
-qwt!()
-```
-
-### Lines
-
-A simple line plot of the 3 columns.
-
-```julia
-plot(rand(100,3))
-```
-
-![](../img/qwt/qwt_example_1.png)
-
-### Functions
-
-Plot multiple functions.  You can also put the function first.
-
-```julia
-plot(0:0.01:4π,[sin,cos])
-```
-
-![](../img/qwt/qwt_example_2.png)
-
-### 
-
-You can also call it with plot(f, xmin, xmax).
-
-```julia
-plot([sin,cos],0,4π)
-```
-
-![](../img/qwt/qwt_example_3.png)
-
-### 
-
-Or make a parametric plot (i.e. plot: (fx(u), fy(u))) with plot(fx, fy, umin, umax).
-
-```julia
-plot(sin,(x->begin  # /home/tom/.julia/v0.4/Plots/docs/example_generation.jl, line 33:
-            sin(2x)
-        end),0,2π)
-```
-
-![](../img/qwt/qwt_example_4.png)
-
-### Global
-
-Change the guides/background without a separate call.
-
-```julia
-plot(rand(10); title="TITLE",xlabel="XLABEL",ylabel="YLABEL",background_color=RGB(0.5,0.5,0.5))
-```
-
-![](../img/qwt/qwt_example_5.png)
-
-### Two-axis
-
-Use the `axis` or `axiss` arguments.
-
-Note: Currently only supported with Qwt and PyPlot
-
-```julia
-plot(Vector[randn(100),randn(100) * 100]; axiss=[:left,:right],ylabel="LEFT",yrightlabel="RIGHT")
-```
-
-![](../img/qwt/qwt_example_6.png)
-
-### Vectors w/ pluralized args
-
-Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).
-
-```julia
-plot(Vector[rand(10),rand(20)]; marker=:ellipse,markersize=8,colors=[:red,:blue])
-```
-
-![](../img/qwt/qwt_example_7.png)
-
-### Build plot in pieces
-
-Start with a base plot...
-
-```julia
-plot(rand(100) / 3; reg=true,fillto=0)
-```
-
-![](../img/qwt/qwt_example_8.png)
-
-### 
-
-and add to it later.
-
-```julia
-scatter!(rand(100); markersize=6,color=:blue)
-```
-
-![](../img/qwt/qwt_example_9.png)
-
-### Heatmaps
-
-
-
-```julia
-heatmap(randn(10000),randn(10000); nbins=100)
-```
-
-![](../img/qwt/qwt_example_10.png)
-
-### Suported line types
-
-All options: (:line, :orderedline, :step, :stepinverted, :sticks, :scatter, :none, :heatmap, :hexbin, :hist, :bar)
-
-```julia
-types = intersect(supportedTypes(),[:line,:step,:stepinverted,:sticks,:scatter])
-n = length(types)
-x = Vector[sort(rand(20)) for i = 1:n]
-y = rand(20,n)
-plot(x,y; linetypes=types,labels=map(string,types))
-```
-
-![](../img/qwt/qwt_example_11.png)
-
-### Supported line styles
-
-All options: (:solid, :dash, :dot, :dashdot, :dashdotdot)
-
-```julia
-styles = setdiff(supportedStyles(),[:auto])
-plot(rand(20,length(styles)); linestyle=:auto,labels=map(string,styles))
-```
-
-![](../img/qwt/qwt_example_12.png)
-
-### Supported marker types
-
-All options: (:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon)
-
-```julia
-markers = setdiff(supportedMarkers(),[:none,:auto])
-plot([fill(i,10) for i = 1:length(markers)]; marker=:auto,labels=map(string,markers),markersize=10)
-```
-
-![](../img/qwt/qwt_example_13.png)
-
-### Bar
-
-x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)
-
-```julia
-bar(randn(1000))
-```
-
-![](../img/qwt/qwt_example_14.png)
-
-### Histogram
-
-note: fillto isn't supported on all backends
-
-```julia
-histogram(randn(1000); nbins=50,fillto=20)
-```
-
-![](../img/qwt/qwt_example_15.png)
-
-### Subplots
-
-  subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-  You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-  number of columns `nc`), or you can set the layout directly with `layout`.  
-
-  Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-
-
-```julia
-subplot(randn(100,5); layout=[1,1,3],linetypes=[:line,:hist,:scatter,:step,:bar],nbins=10,legend=false)
-```
-
-![](../img/qwt/qwt_example_16.png)
-
-### Adding to subplots
-
-Note here the automatic grid layout, as well as the order in which new series are added to the plots.
-
-```julia
-subplot(randn(100,5); n=4)
-```
-
-![](../img/qwt/qwt_example_17.png)
-
-### 
-
-
-
-```julia
-subplot!(randn(100,3))
-```
-
-![](../img/qwt/qwt_example_18.png)
-

docs/unicodeplots_examples.md

@@ -1,211 +0,0 @@
-# Examples for backend: unicodeplots
-
-- Supported arguments: `args`, `axis`, `color`, `kwargs`, `label`, `legend`, `linestyle`, `linetype`, `marker`, `markercolor`, `markersize`, `nbins`, `size`, `title`, `width`, `windowtitle`, `xlabel`, `ylabel`, `yrightlabel`
-- Supported values for axis: `:auto`, `:left`
-- Supported values for linetype: `:none`, `:line`, `:step`, `:sticks`, `:scatter`, `:heatmap`, `:hexbin`, `:hist`, `:bar`
-- Supported values for linestyle: `:auto`, `:solid`
-- Supported values for marker: `:none`, `:auto`, `:ellipse`
-- Is `subplot`/`subplot!` supported? Yes
-
-### Initialize
-
-```julia
-using Plots
-unicodeplots!()
-```
-
-### Lines
-
-A simple line plot of the 3 columns.
-
-```julia
-plot(rand(100,3))
-```
-
-![](../img/unicodeplots/unicodeplots_example_1.png)
-
-### Functions
-
-Plot multiple functions.  You can also put the function first.
-
-```julia
-plot(0:0.01:4π,[sin,cos])
-```
-
-![](../img/unicodeplots/unicodeplots_example_2.png)
-
-### 
-
-You can also call it with plot(f, xmin, xmax).
-
-```julia
-plot([sin,cos],0,4π)
-```
-
-![](../img/unicodeplots/unicodeplots_example_3.png)
-
-### 
-
-Or make a parametric plot (i.e. plot: (fx(u), fy(u))) with plot(fx, fy, umin, umax).
-
-```julia
-plot(sin,(x->begin  # /home/tom/.julia/v0.4/Plots/docs/example_generation.jl, line 33:
-            sin(2x)
-        end),0,2π)
-```
-
-![](../img/unicodeplots/unicodeplots_example_4.png)
-
-### Global
-
-Change the guides/background without a separate call.
-
-```julia
-plot(rand(10); title="TITLE",xlabel="XLABEL",ylabel="YLABEL",background_color=RGB(0.5,0.5,0.5))
-```
-
-![](../img/unicodeplots/unicodeplots_example_5.png)
-
-### Two-axis
-
-Use the `axis` or `axiss` arguments.
-
-Note: Currently only supported with Qwt and PyPlot
-
-```julia
-plot(Vector[randn(100),randn(100) * 100]; axiss=[:left,:right],ylabel="LEFT",yrightlabel="RIGHT")
-```
-
-![](../img/unicodeplots/unicodeplots_example_6.png)
-
-### Vectors w/ pluralized args
-
-Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).
-
-```julia
-plot(Vector[rand(10),rand(20)]; marker=:ellipse,markersize=8,colors=[:red,:blue])
-```
-
-![](../img/unicodeplots/unicodeplots_example_7.png)
-
-### Build plot in pieces
-
-Start with a base plot...
-
-```julia
-plot(rand(100) / 3; reg=true,fillto=0)
-```
-
-![](../img/unicodeplots/unicodeplots_example_8.png)
-
-### 
-
-and add to it later.
-
-```julia
-scatter!(rand(100); markersize=6,color=:blue)
-```
-
-![](../img/unicodeplots/unicodeplots_example_9.png)
-
-### Heatmaps
-
-
-
-```julia
-heatmap(randn(10000),randn(10000); nbins=100)
-```
-
-![](../img/unicodeplots/unicodeplots_example_10.png)
-
-### Suported line types
-
-All options: (:line, :orderedline, :step, :stepinverted, :sticks, :scatter, :none, :heatmap, :hexbin, :hist, :bar)
-
-```julia
-types = intersect(supportedTypes(),[:line,:step,:stepinverted,:sticks,:scatter])
-n = length(types)
-x = Vector[sort(rand(20)) for i = 1:n]
-y = rand(20,n)
-plot(x,y; linetypes=types,labels=map(string,types))
-```
-
-![](../img/unicodeplots/unicodeplots_example_11.png)
-
-### Supported line styles
-
-All options: (:solid, :dash, :dot, :dashdot, :dashdotdot)
-
-```julia
-styles = setdiff(supportedStyles(),[:auto])
-plot(rand(20,length(styles)); linestyle=:auto,labels=map(string,styles))
-```
-
-![](../img/unicodeplots/unicodeplots_example_12.png)
-
-### Supported marker types
-
-All options: (:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon)
-
-```julia
-markers = setdiff(supportedMarkers(),[:none,:auto])
-plot([fill(i,10) for i = 1:length(markers)]; marker=:auto,labels=map(string,markers),markersize=10)
-```
-
-![](../img/unicodeplots/unicodeplots_example_13.png)
-
-### Bar
-
-x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)
-
-```julia
-bar(randn(1000))
-```
-
-![](../img/unicodeplots/unicodeplots_example_14.png)
-
-### Histogram
-
-note: fillto isn't supported on all backends
-
-```julia
-histogram(randn(1000); nbins=50,fillto=20)
-```
-
-![](../img/unicodeplots/unicodeplots_example_15.png)
-
-### Subplots
-
-  subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-  You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-  number of columns `nc`), or you can set the layout directly with `layout`.  
-
-  Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-
-
-```julia
-subplot(randn(100,5); layout=[1,1,3],linetypes=[:line,:hist,:scatter,:step,:bar],nbins=10,legend=false)
-```
-
-![](../img/unicodeplots/unicodeplots_example_16.png)
-
-### Adding to subplots
-
-Note here the automatic grid layout, as well as the order in which new series are added to the plots.
-
-```julia
-subplot(randn(100,5); n=4)
-```
-
-![](../img/unicodeplots/unicodeplots_example_17.png)
-
-### 
-
-
-
-```julia
-subplot!(randn(100,3))
-```
-
-![](../img/unicodeplots/unicodeplots_example_18.png)
-

docs/winston_examples.md

@@ -1,166 +0,0 @@
-# Examples for backend: winston
-
-- Supported arguments: `args`, `axis`, `color`, `kwargs`, `label`, `legend`, `linestyle`, `linetype`, `marker`, `markersize`, `nbins`, `reg`, `size`, `title`, `width`, `windowtitle`, `xlabel`, `ylabel`, `yrightlabel`
-- Supported values for axis: `:auto`, `:left`
-- Supported values for linetype: `:none`, `:line`, `:sticks`, `:scatter`, `:hist`, `:bar`
-- Supported values for linestyle: `:auto`, `:solid`, `:dashdotdot`, `:dot`, `:dash`, `:dashdot`
-- Supported values for marker: `:auto`, `:hexagon`, `:none`, `:dtriangle`, `:ellipse`, `:xcross`, `:rect`, `:star1`, `:star2`, `:cross`, `:utriangle`, `:diamond`
-- Is `subplot`/`subplot!` supported? No
-
-### Initialize
-
-```julia
-using Plots
-winston!()
-```
-
-### Lines
-
-A simple line plot of the 3 columns.
-
-```julia
-plot(rand(100,3))
-```
-
-![](../img/winston/winston_example_1.png)
-
-### Functions
-
-Plot multiple functions.  You can also put the function first.
-
-```julia
-plot(0:0.01:4π,[sin,cos])
-```
-
-![](../img/winston/winston_example_2.png)
-
-### 
-
-You can also call it with plot(f, xmin, xmax).
-
-```julia
-plot([sin,cos],0,4π)
-```
-
-![](../img/winston/winston_example_3.png)
-
-### 
-
-Or make a parametric plot (i.e. plot: (fx(u), fy(u))) with plot(fx, fy, umin, umax).
-
-```julia
-plot(sin,(x->begin  # /home/tom/.julia/v0.4/Plots/docs/example_generation.jl, line 33:
-            sin(2x)
-        end),0,2π)
-```
-
-![](../img/winston/winston_example_4.png)
-
-### Global
-
-Change the guides/background without a separate call.
-
-```julia
-plot(rand(10); title="TITLE",xlabel="XLABEL",ylabel="YLABEL",background_color=RGB(0.5,0.5,0.5))
-```
-
-![](../img/winston/winston_example_5.png)
-
-### Two-axis
-
-Use the `axis` or `axiss` arguments.
-
-Note: Currently only supported with Qwt and PyPlot
-
-```julia
-plot(Vector[randn(100),randn(100) * 100]; axiss=[:left,:right],ylabel="LEFT",yrightlabel="RIGHT")
-```
-
-![](../img/winston/winston_example_6.png)
-
-### Vectors w/ pluralized args
-
-Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).
-
-```julia
-plot(Vector[rand(10),rand(20)]; marker=:ellipse,markersize=8,colors=[:red,:blue])
-```
-
-![](../img/winston/winston_example_7.png)
-
-### Build plot in pieces
-
-Start with a base plot...
-
-```julia
-plot(rand(100) / 3; reg=true,fillto=0)
-```
-
-![](../img/winston/winston_example_8.png)
-
-### 
-
-and add to it later.
-
-```julia
-scatter!(rand(100); markersize=6,color=:blue)
-```
-
-![](../img/winston/winston_example_9.png)
-
-### Suported line types
-
-All options: (:line, :orderedline, :step, :stepinverted, :sticks, :scatter, :none, :heatmap, :hexbin, :hist, :bar)
-
-```julia
-types = intersect(supportedTypes(),[:line,:step,:stepinverted,:sticks,:scatter])
-n = length(types)
-x = Vector[sort(rand(20)) for i = 1:n]
-y = rand(20,n)
-plot(x,y; linetypes=types,labels=map(string,types))
-```
-
-![](../img/winston/winston_example_11.png)
-
-### Supported line styles
-
-All options: (:solid, :dash, :dot, :dashdot, :dashdotdot)
-
-```julia
-styles = setdiff(supportedStyles(),[:auto])
-plot(rand(20,length(styles)); linestyle=:auto,labels=map(string,styles))
-```
-
-![](../img/winston/winston_example_12.png)
-
-### Supported marker types
-
-All options: (:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon)
-
-```julia
-markers = setdiff(supportedMarkers(),[:none,:auto])
-plot([fill(i,10) for i = 1:length(markers)]; marker=:auto,labels=map(string,markers),markersize=10)
-```
-
-![](../img/winston/winston_example_13.png)
-
-### Bar
-
-x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)
-
-```julia
-bar(randn(1000))
-```
-
-![](../img/winston/winston_example_14.png)
-
-### Histogram
-
-note: fillto isn't supported on all backends
-
-```julia
-histogram(randn(1000); nbins=50,fillto=20)
-```
-
-![](../img/winston/winston_example_15.png)
-