diff --git a/.gitignore b/.gitignore
index 7622be7..1c4a1b0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,6 @@
 
 # Build
 /examples/build/*
+
+# vim temp files
+*.sw*
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..d6175a2
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,6 @@
+language: minimal
+dist: trusty
+services:
+  - docker
+script:
+  - make -C contrib docker_build
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..bb2decd
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,133 @@
+cmake_minimum_required(VERSION 3.8 FATAL_ERROR)
+project(matplotlib_cpp LANGUAGES CXX)
+
+include(GNUInstallDirs)
+set(PACKAGE_NAME matplotlib_cpp)
+set(INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/${PACKAGE_NAME}/cmake)
+
+
+# Library target
+add_library(matplotlib_cpp INTERFACE)
+target_include_directories(matplotlib_cpp
+  INTERFACE
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/examples>
+    $<INSTALL_INTERFACE:include>
+)
+target_compile_features(matplotlib_cpp INTERFACE
+  cxx_std_11
+)
+# TODO: Use `Development.Embed` component when requiring cmake >= 3.18
+find_package(Python3 COMPONENTS Interpreter Development REQUIRED)
+target_link_libraries(matplotlib_cpp INTERFACE
+  Python3::Python
+  Python3::Module
+)
+find_package(Python3 COMPONENTS NumPy)
+if(Python3_NumPy_FOUND)
+  target_link_libraries(matplotlib_cpp INTERFACE
+    Python3::NumPy
+  )
+else()
+  target_compile_definitions(matplotlib_cpp INTERFACE WITHOUT_NUMPY)
+endif()
+install(
+  TARGETS matplotlib_cpp
+  EXPORT install_targets
+)
+
+
+# Examples
+add_executable(minimal examples/minimal.cpp)
+target_link_libraries(minimal PRIVATE matplotlib_cpp)
+set_target_properties(minimal PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(basic examples/basic.cpp)
+target_link_libraries(basic PRIVATE matplotlib_cpp)
+set_target_properties(basic PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(modern examples/modern.cpp)
+target_link_libraries(modern PRIVATE matplotlib_cpp)
+set_target_properties(modern PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(animation examples/animation.cpp)
+target_link_libraries(animation PRIVATE matplotlib_cpp)
+set_target_properties(animation PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(nonblock examples/nonblock.cpp)
+target_link_libraries(nonblock PRIVATE matplotlib_cpp)
+set_target_properties(nonblock PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(xkcd examples/xkcd.cpp)
+target_link_libraries(xkcd PRIVATE matplotlib_cpp)
+set_target_properties(xkcd PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(bar examples/bar.cpp)
+target_link_libraries(bar PRIVATE matplotlib_cpp)
+set_target_properties(bar PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(fill_inbetween examples/fill_inbetween.cpp)
+target_link_libraries(fill_inbetween PRIVATE matplotlib_cpp)
+set_target_properties(fill_inbetween PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(fill examples/fill.cpp)
+target_link_libraries(fill PRIVATE matplotlib_cpp)
+set_target_properties(fill PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(update examples/update.cpp)
+target_link_libraries(update PRIVATE matplotlib_cpp)
+set_target_properties(update PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(subplot2grid examples/subplot2grid.cpp)
+target_link_libraries(subplot2grid PRIVATE matplotlib_cpp)
+set_target_properties(subplot2grid PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+add_executable(lines3d examples/lines3d.cpp)
+target_link_libraries(lines3d PRIVATE matplotlib_cpp)
+set_target_properties(lines3d PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+if(Python3_NumPy_FOUND)
+  add_executable(surface examples/surface.cpp)
+  target_link_libraries(surface PRIVATE matplotlib_cpp)
+  set_target_properties(surface PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+  add_executable(colorbar examples/colorbar.cpp)
+  target_link_libraries(colorbar PRIVATE matplotlib_cpp)
+  set_target_properties(colorbar PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+  add_executable(contour examples/contour.cpp)
+  target_link_libraries(contour PRIVATE matplotlib_cpp)
+  set_target_properties(contour PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
+  add_executable(spy examples/spy.cpp)
+  target_link_libraries(spy PRIVATE matplotlib_cpp)
+  set_target_properties(spy PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+endif()
+
+
+# Install headers
+install(FILES
+  "${PROJECT_SOURCE_DIR}/matplotlibcpp.h"
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+
+# Install targets file
+install(EXPORT install_targets
+  FILE
+    ${PACKAGE_NAME}Targets.cmake
+  NAMESPACE
+    ${PACKAGE_NAME}::
+  DESTINATION
+    ${INSTALL_CONFIGDIR}
+)
+
+
+# Install matplotlib_cppConfig.cmake
+include(CMakePackageConfigHelpers)
+configure_package_config_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${PACKAGE_NAME}Config.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE_NAME}Config.cmake
+  INSTALL_DESTINATION ${INSTALL_CONFIGDIR}
+)
+install(FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE_NAME}Config.cmake
+  DESTINATION ${INSTALL_CONFIGDIR}
+)
diff --git a/Makefile b/Makefile
deleted file mode 100644
index 5b10194..0000000
--- a/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-examples: minimal basic modern
-
-minimal: examples/minimal.cpp matplotlibcpp.h
-	cd examples && g++ -DWITHOUT_NUMPY minimal.cpp -I/usr/include/python2.7 -lpython2.7 -o minimal -std=c++11
-
-basic: examples/basic.cpp matplotlibcpp.h
-	cd examples && g++ basic.cpp -I/usr/include/python2.7 -lpython2.7 -o basic
-
-modern: examples/modern.cpp matplotlibcpp.h
-	cd examples && g++ modern.cpp -I/usr/include/python2.7 -lpython2.7 -o modern -std=c++11
-
diff --git a/README.md b/README.md
index b6a84f2..0f8479f 100644
--- a/README.md
+++ b/README.md
@@ -9,87 +9,185 @@ It is built to resemble the plotting API used by Matlab and matplotlib.
 Usage
 -----
 Complete minimal example:
+```cpp
+#include "matplotlibcpp.h"
+namespace plt = matplotlibcpp;
+int main() {
+    plt::plot({1,3,2,4});
+    plt::show();
+}
+```
+    g++ minimal.cpp -std=c++11 -I/usr/include/python2.7 -lpython2.7
 
-    #include "matplotlibcpp.h"
-    namespace plt = matplotlibcpp;
-    int main() {
-        plt::plot({1,2,3,4});
-        plt::show();
-    }
-    
-    // g++ minimal.cpp -std=c++11 -I/usr/include/python2.7 -lpython2.7
+**Result:**
 
-Result: ![Minimal example](./examples/minimal.png)
+![Minimal example](./examples/minimal.png)
 
 A more comprehensive example:
+```cpp
+#include "matplotlibcpp.h"
+#include <cmath>
+
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    // Prepare data.
+    int n = 5000;
+    std::vector<double> x(n), y(n), z(n), w(n,2);
+    for(int i=0; i<n; ++i) {
+        x.at(i) = i*i;
+        y.at(i) = sin(2*M_PI*i/360.0);
+        z.at(i) = log(i);
+    }
 
-    #include "matplotlibcpp.h"
-    #include <cmath>
+    // Set the size of output image to 1200x780 pixels
+    plt::figure_size(1200, 780);
+    // Plot line from given x and y data. Color is selected automatically.
+    plt::plot(x, y);
+    // Plot a red dashed line from given x and y data.
+    plt::plot(x, w,"r--");
+    // Plot a line whose name will show up as "log(x)" in the legend.
+    plt::named_plot("log(x)", x, z);
+    // Set x-axis to interval [0,1000000]
+    plt::xlim(0, 1000*1000);
+    // Add graph title
+    plt::title("Sample figure");
+    // Enable legend.
+    plt::legend();
+    // Save the image (file format is determined by the extension)
+    plt::save("./basic.png");
+}
+```
+    g++ basic.cpp -I/usr/include/python2.7 -lpython2.7
+
+**Result:**
+
+![Basic example](./examples/basic.png)
+
+Alternatively, matplotlib-cpp also supports some C++11-powered syntactic sugar:
+```cpp
+#include <cmath>
+#include "matplotlibcpp.h"
+
+using namespace std;
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    // Prepare data.
+    int n = 5000; // number of data points
+    vector<double> x(n),y(n);
+    for(int i=0; i<n; ++i) {
+        double t = 2*M_PI*i/n;
+        x.at(i) = 16*sin(t)*sin(t)*sin(t);
+        y.at(i) = 13*cos(t) - 5*cos(2*t) - 2*cos(3*t) - cos(4*t);
+    }
 
-    namespace plt = matplotlibcpp;
+    // plot() takes an arbitrary number of (x,y,format)-triples.
+    // x must be iterable (that is, anything providing begin(x) and end(x)),
+    // y must either be callable (providing operator() const) or iterable.
+    plt::plot(x, y, "r-", x, [](double d) { return 12.5+abs(sin(d)); }, "k-");
 
-    int main() 
-    {
-        // Prepare data.
-        int n = 5000;
-        std::vector<double> x(n), y(n), z(n), w(n,2);
-        for(int i=0; i<n; ++i) {
-            x.at(i) = i*i;
-            y.at(i) = sin(2*M_PI*i/360.0);
-            z.at(i) = log(i);
-        }
 
-        // Plot line from given x and y data. Color is selected automatically.
-        plt::plot(x, y);
-        // Plot a red dashed line from given x and y data.
-        plt::plot(x, w,"r--");
-        // Plot a line whose name will show up as "log(x)" in the legend.
-        plt::named_plot("log(x)", x, z);
-
-        // Set x-axis to interval [0,1000000]
-        plt::xlim(0, 1000*1000);
-        // Enable legend.
-        plt::legend();
-        // Save the image (file format is determined by the extension)
-        plt::save("./basic.png");
+    // show plots
+    plt::show();
+}
+```
+    g++ modern.cpp -std=c++11 -I/usr/include/python2.7 -lpython
+
+**Result:**
+
+![Modern example](./examples/modern.png)
+
+Or some *funny-looking xkcd-styled* example:
+```cpp
+#include "matplotlibcpp.h"
+#include <vector>
+#include <cmath>
+
+namespace plt = matplotlibcpp;
+
+int main() {
+    std::vector<double> t(1000);
+    std::vector<double> x(t.size());
+
+    for(size_t i = 0; i < t.size(); i++) {
+        t[i] = i / 100.0;
+        x[i] = sin(2.0 * M_PI * 1.0 * t[i]);
     }
 
-    // g++ basic.cpp -I/usr/include/python2.7 -lpython2.7
+    plt::xkcd();
+    plt::plot(t, x);
+    plt::title("AN ORDINARY SIN WAVE");
+    plt::save("xkcd.png");
+}
 
-Result: ![Basic example](./examples/basic.png)
+```
+    g++ xkcd.cpp -std=c++11 -I/usr/include/python2.7 -lpython2.7
 
-matplotlib-cpp doesn't require C++11, but will enable some additional syntactic sugar when available:
+**Result:**
 
-    #include <cmath>
-    #include "matplotlibcpp.h"
+![xkcd example](./examples/xkcd.png)
 
-    using namespace std;
-    namespace plt = matplotlibcpp;
+When working with vector fields, you might be interested in quiver plots:
+```cpp
+#include "../matplotlibcpp.h"
 
-    int main() 
-    {    
-        // Prepare data.
-        int n = 5000; // number of data points
-        vector<double> x(n),y(n); 
-        for(int i=0; i<n; ++i) {
-            double t = 2*M_PI*i/n;
-            x.at(i) = 16*sin(t)*sin(t)*sin(t);
-            y.at(i) = 13*cos(t) - 5*cos(2*t) - 2*cos(3*t) - cos(4*t);
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    // u and v are respectively the x and y components of the arrows we're plotting
+    std::vector<int> x, y, u, v;
+    for (int i = -5; i <= 5; i++) {
+        for (int j = -5; j <= 5; j++) {
+            x.push_back(i);
+            u.push_back(-i);
+            y.push_back(j);
+            v.push_back(-j);
         }
+    }
+
+    plt::quiver(x, y, u, v);
+    plt::show();
+}
+```
+    g++ quiver.cpp -std=c++11 -I/usr/include/python2.7 -lpython2.7
+
+**Result:**
+
+![quiver example](./examples/quiver.png)
 
-        // plot() takes an arbitrary number of (x,y,format)-triples. 
-        // x must be iterable (that is, anything providing begin(x) and end(x)),
-        // y must either be callable (providing operator() const) or iterable. 
-        plt::plot(x, y, "r-", x, [](double d) { return 12.5+abs(sin(d)); }, "k-");
+When working with 3d functions, you might be interested in 3d plots:
+```cpp
+#include "../matplotlibcpp.h"
 
+namespace plt = matplotlibcpp;
 
-        // show plots
-        plt::show();
-    } 
-    
-    // g++ modern.cpp -std=c++11 -I/usr/include/python2.7 -lpython
+int main()
+{
+    std::vector<std::vector<double>> x, y, z;
+    for (double i = -5; i <= 5;  i += 0.25) {
+        std::vector<double> x_row, y_row, z_row;
+        for (double j = -5; j <= 5; j += 0.25) {
+            x_row.push_back(i);
+            y_row.push_back(j);
+            z_row.push_back(::std::sin(::std::hypot(i, j)));
+        }
+        x.push_back(x_row);
+        y.push_back(y_row);
+        z.push_back(z_row);
+    }
+
+    plt::plot_surface(x, y, z);
+    plt::show();
+}
+```
+
+**Result:**
 
-Result: ![Modern example](./examples/modern.png)
+![surface example](./examples/surface.png)
 
 Installation
 ------------
@@ -98,53 +196,79 @@ matplotlib-cpp works by wrapping the popular python plotting library matplotlib.
 This means you have to have a working python installation, including development headers.
 On Ubuntu:
 
-    sudo aptitude install python-matplotlib python-numpy python2.7-dev
+    sudo apt-get install python-matplotlib python-numpy python2.7-dev
 
 If, for some reason, you're unable to get a working installation of numpy on your system,
-you can add the define `WITHOUT_NUMPY` to erase this dependency.
+you can define the macro `WITHOUT_NUMPY` before including the header file to erase this
+dependency.
 
-The C++-part of the library consists of the single header file `matplotlibcpp.h` which can be placed
-anywhere.
+The C++-part of the library consists of the single header file `matplotlibcpp.h` which
+can be placed anywhere.
 
-Since a python interpreter is opened internally, it is necessary to link against `libpython2.7` in order to use
-matplotlib-cpp.
+Since a python interpreter is opened internally, it is necessary to link
+against `libpython` in order to user matplotlib-cpp. Most versions should
+work, although python likes to randomly break compatibility from time to time
+so some caution is advised when using the bleeding edge.
 
-# CMake
 
-If you prefer to use CMake as build system, you will want to add something like this to your
-CMakeLists.txt:
+# CMake
 
-    find_package(PythonLibs 2.7)
-    target_include_directories(myproject ${PYTHON_INCLUDE_DIRS})
-    target_link_libraries(myproject ${PYTHON_LIBRARIES)
+The C++ code is compatible to both python2 and python3. However, the `CMakeLists.txt`
+file is currently set up to use python3 by default, so if python2 is required this
+has to be changed manually. (a PR that adds a cmake option for this would be highly
+welcomed)
 
-# Python 3
+**NOTE**: By design (of python), only a single python interpreter can be created per
+process. When using this library, *no other* library that is spawning a python
+interpreter internally can be used.
 
-This library supports both python2 and python3 (although the python3 support is probably far less tested,
-so it is recommended to prefer python2.7). To switch the used python version, simply change
-the compiler flags accordingly.
+To compile the code without using cmake, the compiler invocation should look like
+this:
 
-    g++ example.cpp -I/usr/include/python3.6 -lpython3.6
+    g++ example.cpp -I/usr/include/python2.7 -lpython2.7
 
-The same technique can be used for linking against a custom build of python
+This can also be used for linking against a custom build of python
 
     g++ example.cpp -I/usr/local/include/fancy-python4 -L/usr/local/lib -lfancy-python4
 
+# Vcpkg
+
+You can download and install matplotlib-cpp using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    vcpkg install matplotlib-cpp
+  
+The matplotlib-cpp port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+
+# C++11
+
+Currently, c++11 is required to build matplotlib-cpp. The last working commit that did
+not have this requirement was `717e98e752260245407c5329846f5d62605eff08`.
+
+Note that support for c++98 was dropped more or less accidentally, so if you have to work
+with an ancient compiler and still want to enjoy the latest additional features, I'd
+probably merge a PR that restores support.
+
+
 
 Why?
 ----
-I initially started this library during my diploma thesis. The usual approach of 
+I initially started this library during my diploma thesis. The usual approach of
 writing data from the c++ algorithm to a file and afterwards parsing and plotting
 it in python using matplotlib proved insufficient: Keeping the algorithm
-and plotting code in sync requires a lot of effort when the C++ code frequently and substantially 
+and plotting code in sync requires a lot of effort when the C++ code frequently and substantially
 changes. Additionally, the python yaml parser was not able to cope with files that
 exceed a few hundred megabytes in size.
 
-Therefore, I was looking for a C++ plotting library that was extremely to use
-and easy to add into an existing codebase, preferrably header-only. When I found
+Therefore, I was looking for a C++ plotting library that was extremely easy to use
+and to add into an existing codebase, preferably header-only. When I found
 none, I decided to write one myself, which is basically a C++ wrapper around
 matplotlib. As you can see from the above examples, plotting data and saving it
-to an image file can be done is as few as two lines of code.
+to an image file can be done as few as two lines of code.
 
 The general approach of providing a simple C++ API for utilizing python code
 was later generalized and extracted into a separate, more powerful
@@ -165,3 +289,6 @@ Todo/Issues/Wishlist
 
 * If you use Anaconda on Windows, you might need to set PYTHONHOME to Anaconda home directory and QT_QPA_PLATFORM_PLUGIN_PATH to %PYTHONHOME%Library/plugins/platforms. The latter is for especially when you get the error which says 'This application failed to start because it could not find or load the Qt platform plugin "windows"
 in "".'
+
+* MacOS: `Unable to import matplotlib.pyplot`. Cause: In mac os image rendering back end of matplotlib (what-is-a-backend to render using the API of Cocoa by default). There is Qt4Agg and GTKAgg and as a back-end is not the default. Set the back end of macosx that is differ compare with other windows or linux os.
+Solution is described [here](https://stackoverflow.com/questions/21784641/installation-issue-with-matplotlib-python?noredirect=1&lq=1), additional information can be found there too(see links in answers).
diff --git a/cmake/matplotlib_cppConfig.cmake.in b/cmake/matplotlib_cppConfig.cmake.in
new file mode 100644
index 0000000..86d25d0
--- /dev/null
+++ b/cmake/matplotlib_cppConfig.cmake.in
@@ -0,0 +1,10 @@
+get_filename_component(matplotlib_cpp_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+
+if(NOT TARGET matplotlib_cpp::matplotlib_cpp)
+  find_package(Python3 COMPONENTS Interpreter Development REQUIRED)
+  find_package(Python3 COMPONENTS NumPy)
+  include("${matplotlib_cpp_CMAKE_DIR}/matplotlib_cppTargets.cmake")
+
+  get_target_property(matplotlib_cpp_INCLUDE_DIRS matplotlib_cpp::matplotlib_cpp INTERFACE_INCLUDE_DIRECTORIES)
+
+endif()
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
deleted file mode 100644
index ba14b86..0000000
--- a/contrib/CMakeLists.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-cmake_minimum_required(VERSION 3.1)
-project (MatplotlibCPP_Test)
-
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-include_directories(${PYTHONHOME}/include)
-link_directories(${PYTHONHOME}/libs)
-
-add_definitions(-DMATPLOTLIBCPP_PYTHON_HEADER=Python.h)
-
-# message(STATUS "*** dump start cmake variables ***")
-# get_cmake_property(_variableNames VARIABLES)
-# foreach(_variableName ${_variableNames})
-        # message(STATUS "${_variableName}=${${_variableName}}")
-# endforeach()
-# message(STATUS "*** dump end ***")
-
-add_executable(minimal ${CMAKE_CURRENT_SOURCE_DIR}/../examples/minimal.cpp)
-add_executable(basic ${CMAKE_CURRENT_SOURCE_DIR}/../examples/basic.cpp)
-add_executable(modern ${CMAKE_CURRENT_SOURCE_DIR}/../examples/modern.cpp)
diff --git a/contrib/Dockerfile b/contrib/Dockerfile
new file mode 100644
index 0000000..850466f
--- /dev/null
+++ b/contrib/Dockerfile
@@ -0,0 +1,27 @@
+FROM debian:10 AS builder
+RUN apt-get update \
+ && apt-get install --yes --no-install-recommends \
+    g++ \
+    libpython3-dev \
+    make \
+    python3 \
+    python3-dev \
+    python3-numpy
+
+ADD Makefile matplotlibcpp.h numpy_flags.py /opt/
+ADD examples/*.cpp /opt/examples/
+RUN cd /opt \
+ && make PYTHON_BIN=python3 \
+ && ls examples/build
+
+FROM debian:10
+RUN apt-get update \
+ && apt-get install --yes --no-install-recommends \
+    libpython3-dev \
+    python3-matplotlib \
+    python3-numpy
+
+COPY --from=builder /opt/examples/build /opt/
+RUN cd /opt \
+ && ls \
+ && ./basic
diff --git a/contrib/Makefile b/contrib/Makefile
new file mode 100644
index 0000000..f659cd9
--- /dev/null
+++ b/contrib/Makefile
@@ -0,0 +1,6 @@
+all: docker_build
+
+docker_build:
+	cd .. && \
+	docker build . -f contrib/Dockerfile -t matplotlibcpp && \
+	cd contrib
diff --git a/contrib/README.md b/contrib/README.md
index efc0a50..0af8515 100644
--- a/contrib/README.md
+++ b/contrib/README.md
@@ -8,12 +8,25 @@ contributors are not required to and may be unable to check whether their
 changes break any of them.
 
 ## Windows support
+Tested on the following environment
+* Windows 10 - 64bit
+* Anaconda 4.3 (64 bit)
+* Python 3.6.0
+* CMake 3.9.4
+* Visual Studio 2017, 2015, 2013
 
 ### Configuring and Building Samples
+1. Edit WinBuild.cmd for your environment(Line:5-7)
+    if NOT DEFINED MSVC_VERSION set MSVC_VERSION=[Your Visual Studio Version(12, 14, 15)]
+    if NOT DEFINED CMAKE_CONFIG set CMAKE_CONFIG=Release
+    if NOT DEFINED PYTHONHOME   set PYTHONHOME=[Your Python Path]
 
+2. Run WinBuild.cmd to build
 ```cmd
 > cd contrib
 > WinBuild.cmd
 ```
-
 The `WinBuild.cmd` will set up temporal ENV variables and build binaries in (matplotlib root)/examples with the Release configuration.
+
+3. Find exe files in examples/build/Release
+Note: platforms folder is necessary to make qt works.
diff --git a/contrib/WinBuild.cmd b/contrib/WinBuild.cmd
index 4e3b450..9dfd627 100644
--- a/contrib/WinBuild.cmd
+++ b/contrib/WinBuild.cmd
@@ -1,9 +1,14 @@
 @echo off
 @setlocal EnableDelayedExpansion
 
-if NOT DEFINED MSVC_VERSION set MSVC_VERSION=14
+REM ------Set Your Environment------------------------------- 
+if NOT DEFINED MSVC_VERSION set MSVC_VERSION=15
 if NOT DEFINED CMAKE_CONFIG set CMAKE_CONFIG=Release
 if NOT DEFINED PYTHONHOME   set PYTHONHOME=C:/Users/%username%/Anaconda3
+REM ---------------------------------------------------------
+
+set KEY_NAME="HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\VisualStudio\SxS\VS7"
+set VALUE_NAME=15.0
 
 if "%MSVC_VERSION%"=="14" (
     if "%processor_architecture%" == "AMD64" (
@@ -14,13 +19,23 @@ if "%MSVC_VERSION%"=="14" (
 ) else if "%MSVC_VERSION%"=="12" (
     if "%processor_architecture%" == "AMD64" (
         set CMAKE_GENERATOR=Visual Studio 12 2013 Win64
-    
     ) else (
         set CMAKE_GENERATOR=Visual Studio 12 2013
     )
+) else if "%MSVC_VERSION%"=="15" (
+    if "%processor_architecture%" == "AMD64" (
+        set CMAKE_GENERATOR=Visual Studio 15 2017 Win64
+    ) else (
+        set CMAKE_GENERATOR=Visual Studio 15 2017
+    )
+)
+if "%MSVC_VERSION%"=="15" (
+    for /F "usebackq tokens=1,2,*" %%A in (`REG QUERY %KEY_NAME% /v %VALUE_NAME%`) do (
+        set batch_file=%%CVC\Auxiliary\Build\vcvarsall.bat
+    )
+) else (
+    set batch_file=!VS%MSVC_VERSION%0COMNTOOLS!..\..\VC\vcvarsall.bat
 )
-
-set batch_file=!VS%MSVC_VERSION%0COMNTOOLS!..\..\VC\vcvarsall.bat
 call "%batch_file%" %processor_architecture%
 
 pushd ..
diff --git a/examples/.gitignore b/examples/.gitignore
new file mode 100644
index 0000000..3da8ad6
--- /dev/null
+++ b/examples/.gitignore
@@ -0,0 +1,14 @@
+animation
+bar
+basic
+fill
+fill_inbetween
+imshow
+minimal
+modern
+nonblock
+quiver
+subplot
+surface
+update
+xkcd
diff --git a/examples/animation.cpp b/examples/animation.cpp
new file mode 100644
index 0000000..d979430
--- /dev/null
+++ b/examples/animation.cpp
@@ -0,0 +1,36 @@
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include "../matplotlibcpp.h"
+
+namespace plt = matplotlibcpp;
+
+int main()
+{
+	int n = 1000;
+	std::vector<double> x, y, z;
+
+	for(int i=0; i<n; i++) {
+		x.push_back(i*i);
+		y.push_back(sin(2*M_PI*i/360.0));
+		z.push_back(log(i));
+
+		if (i % 10 == 0) {
+			// Clear previous plot
+			plt::clf();
+			// Plot line from given x and y data. Color is selected automatically.
+			plt::plot(x, y);
+			// Plot a line whose name will show up as "log(x)" in the legend.
+			plt::named_plot("log(x)", x, z);
+
+			// Set x-axis to interval [0,1000000]
+			plt::xlim(0, n*n);
+
+			// Add graph title
+			plt::title("Sample figure");
+			// Enable legend.
+			plt::legend();
+			// Display plot continuously
+			plt::pause(0.01);
+		}
+	}
+}
diff --git a/examples/animation.gif b/examples/animation.gif
new file mode 100644
index 0000000..ef8eb5a
Binary files /dev/null and b/examples/animation.gif differ
diff --git a/examples/bar.cpp b/examples/bar.cpp
new file mode 100644
index 0000000..86423ad
--- /dev/null
+++ b/examples/bar.cpp
@@ -0,0 +1,18 @@
+#define _USE_MATH_DEFINES
+
+#include <iostream>
+#include <string>
+#include "../matplotlibcpp.h"
+namespace plt = matplotlibcpp;
+
+int main(int argc, char **argv) {
+    std::vector<int> test_data;
+    for (int i = 0; i < 20; i++) {
+        test_data.push_back(i);
+    }
+
+    plt::bar(test_data);
+    plt::show();
+
+    return (0);
+}
diff --git a/examples/bar.png b/examples/bar.png
new file mode 100644
index 0000000..be6af0f
Binary files /dev/null and b/examples/bar.png differ
diff --git a/examples/basic.cpp b/examples/basic.cpp
index e149ed4..2dc34c7 100644
--- a/examples/basic.cpp
+++ b/examples/basic.cpp
@@ -1,4 +1,5 @@
 #define _USE_MATH_DEFINES
+#include <iostream>
 #include <cmath>
 #include "../matplotlibcpp.h"
 
@@ -6,29 +7,38 @@ namespace plt = matplotlibcpp;
 
 int main() 
 {
-	// Prepare data.
-	int n = 5000;
-	std::vector<double> x(n), y(n), z(n), w(n,2);
-	for(int i=0; i<n; ++i) {
-		x.at(i) = i*i;
-		y.at(i) = sin(2*M_PI*i/360.0);
-		z.at(i) = log(i);
-	}
-
-	// Plot line from given x and y data. Color is selected automatically.
-	plt::plot(x, y);
-	// Plot a red dashed line from given x and y data.
-	plt::plot(x, w,"r--");
-	// Plot a line whose name will show up as "log(x)" in the legend.
-	plt::named_plot("log(x)", x, z);
-
-	// Set x-axis to interval [0,1000000]
-	plt::xlim(0, 1000*1000);
-
-	// Add graph title
-	plt::title("Sample figure");
-	// Enable legend.
-	plt::legend();
-	// save figure
-	plt::save("./basic.png");
+    // Prepare data.
+    int n = 5000;
+    std::vector<double> x(n), y(n), z(n), w(n,2);
+    for(int i=0; i<n; ++i) {
+        x.at(i) = i*i;
+        y.at(i) = sin(2*M_PI*i/360.0);
+        z.at(i) = log(i);
+    }
+    
+    // Set the size of output image = 1200x780 pixels
+    plt::figure_size(1200, 780);
+
+    // Plot line from given x and y data. Color is selected automatically.
+    plt::plot(x, y);
+
+    // Plot a red dashed line from given x and y data.
+    plt::plot(x, w,"r--");
+
+    // Plot a line whose name will show up as "log(x)" in the legend.
+    plt::named_plot("log(x)", x, z);
+
+    // Set x-axis to interval [0,1000000]
+    plt::xlim(0, 1000*1000);
+
+    // Add graph title
+    plt::title("Sample figure");
+
+    // Enable legend.
+    plt::legend();
+
+    // save figure
+    const char* filename = "./basic.png";
+    std::cout << "Saving result to " << filename << std::endl;;
+    plt::save(filename);
 }
diff --git a/examples/basic.png b/examples/basic.png
index eef82a2..4d87ff0 100644
Binary files a/examples/basic.png and b/examples/basic.png differ
diff --git a/examples/colorbar.cpp b/examples/colorbar.cpp
new file mode 100644
index 0000000..f53e01d
--- /dev/null
+++ b/examples/colorbar.cpp
@@ -0,0 +1,32 @@
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include <iostream>
+#include "../matplotlibcpp.h"
+
+using namespace std;
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    // Prepare data
+    int ncols = 500, nrows = 300;
+    std::vector<float> z(ncols * nrows);
+    for (int j=0; j<nrows; ++j) {
+        for (int i=0; i<ncols; ++i) {
+            z.at(ncols * j + i) = std::sin(std::hypot(i - ncols/2, j - nrows/2));
+        }
+    }
+
+    const float* zptr = &(z[0]);
+    const int colors = 1;
+
+    plt::title("My matrix");
+    PyObject* mat;
+    plt::imshow(zptr, nrows, ncols, colors, {}, &mat);
+    plt::colorbar(mat);
+
+    // Show plots
+    plt::show();
+    plt::close();
+    Py_DECREF(mat);
+}
diff --git a/examples/contour.cpp b/examples/contour.cpp
new file mode 100644
index 0000000..9289d0a
--- /dev/null
+++ b/examples/contour.cpp
@@ -0,0 +1,24 @@
+#include "../matplotlibcpp.h"
+
+#include <cmath>
+
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    std::vector<std::vector<double>> x, y, z;
+    for (double i = -5; i <= 5;  i += 0.25) {
+        std::vector<double> x_row, y_row, z_row;
+        for (double j = -5; j <= 5; j += 0.25) {
+            x_row.push_back(i);
+            y_row.push_back(j);
+            z_row.push_back(::std::sin(::std::hypot(i, j)));
+        }
+        x.push_back(x_row);
+        y.push_back(y_row);
+        z.push_back(z_row);
+    }
+
+    plt::contour(x, y, z);
+    plt::show();
+}
diff --git a/examples/fill.cpp b/examples/fill.cpp
new file mode 100644
index 0000000..6059b47
--- /dev/null
+++ b/examples/fill.cpp
@@ -0,0 +1,35 @@
+#define _USE_MATH_DEFINES
+#include "../matplotlibcpp.h"
+#include <cmath>
+
+using namespace std;
+namespace plt = matplotlibcpp;
+
+// Example fill plot taken from:
+// https://matplotlib.org/gallery/misc/fill_spiral.html
+int main() {
+    // Prepare data.
+    vector<double> theta;
+    for (double d = 0; d < 8 * M_PI; d += 0.1)
+        theta.push_back(d);
+
+    const int a = 1;
+    const double b = 0.2;
+
+    for (double dt = 0; dt < 2 * M_PI; dt += M_PI/2.0) {
+        vector<double> x1, y1, x2, y2;
+        for (double th : theta) {
+            x1.push_back( a*cos(th + dt) * exp(b*th) );
+            y1.push_back( a*sin(th + dt) * exp(b*th) );
+
+            x2.push_back( a*cos(th + dt + M_PI/4.0) * exp(b*th) );
+            y2.push_back( a*sin(th + dt + M_PI/4.0) * exp(b*th) );
+        }
+
+        x1.insert(x1.end(), x2.rbegin(), x2.rend());
+        y1.insert(y1.end(), y2.rbegin(), y2.rend());
+
+        plt::fill(x1, y1, {});
+    }
+    plt::show();
+}
diff --git a/examples/fill.png b/examples/fill.png
new file mode 100644
index 0000000..aa1fc0d
Binary files /dev/null and b/examples/fill.png differ
diff --git a/examples/fill_between.png b/examples/fill_between.png
new file mode 100644
index 0000000..a199423
Binary files /dev/null and b/examples/fill_between.png differ
diff --git a/examples/fill_inbetween.cpp b/examples/fill_inbetween.cpp
new file mode 100644
index 0000000..788d008
--- /dev/null
+++ b/examples/fill_inbetween.cpp
@@ -0,0 +1,28 @@
+#define _USE_MATH_DEFINES
+#include "../matplotlibcpp.h"
+#include <cmath>
+#include <iostream>
+
+using namespace std;
+namespace plt = matplotlibcpp;
+
+int main() {
+  // Prepare data.
+  int n = 5000;
+  std::vector<double> x(n), y(n), z(n), w(n, 2);
+  for (int i = 0; i < n; ++i) {
+    x.at(i) = i * i;
+    y.at(i) = sin(2 * M_PI * i / 360.0);
+    z.at(i) = log(i);
+  }
+
+  // Prepare keywords to pass to PolyCollection. See
+  // https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.fill_between.html
+  std::map<string, string> keywords;
+  keywords["alpha"] = "0.4";
+  keywords["color"] = "grey";
+  keywords["hatch"] = "-";
+
+  plt::fill_between(x, y, z, keywords);
+  plt::show();
+}
diff --git a/examples/imshow.cpp b/examples/imshow.cpp
new file mode 100644
index 0000000..b11661e
--- /dev/null
+++ b/examples/imshow.cpp
@@ -0,0 +1,29 @@
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include <iostream>
+#include "../matplotlibcpp.h"
+
+using namespace std;
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    // Prepare data
+    int ncols = 500, nrows = 300;
+    std::vector<float> z(ncols * nrows);
+    for (int j=0; j<nrows; ++j) {
+        for (int i=0; i<ncols; ++i) {
+            z.at(ncols * j + i) = std::sin(std::hypot(i - ncols/2, j - nrows/2));
+        }
+    }
+
+    const float* zptr = &(z[0]);
+    const int colors = 1;
+
+    plt::title("My matrix");
+    plt::imshow(zptr, nrows, ncols, colors);
+
+    // Show plots
+    plt::save("imshow.png");
+    std::cout << "Result saved to 'imshow.png'.\n";
+}
diff --git a/examples/lines3d.cpp b/examples/lines3d.cpp
new file mode 100644
index 0000000..fd4610d
--- /dev/null
+++ b/examples/lines3d.cpp
@@ -0,0 +1,30 @@
+#define _USE_MATH_DEFINES
+#include "../matplotlibcpp.h"
+#include <cmath>
+
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    std::vector<double> x, y, z;
+    double theta, r;
+    double z_inc = 4.0/99.0; double theta_inc = (8.0 * M_PI)/99.0;
+    
+    for (double i = 0; i < 100; i += 1) {
+        theta = -4.0 * M_PI + theta_inc*i;
+        z.push_back(-2.0 + z_inc*i);
+        r = z[i]*z[i] + 1;
+        x.push_back(r * sin(theta));
+        y.push_back(r * cos(theta));
+    }
+
+    std::map<std::string, std::string> keywords;
+    keywords.insert(std::pair<std::string, std::string>("label", "parametric curve") );
+
+    plt::plot3(x, y, z, keywords);
+    plt::xlabel("x label");
+    plt::ylabel("y label");
+    plt::set_zlabel("z label"); // set_zlabel rather than just zlabel, in accordance with the Axes3D method
+    plt::legend();
+    plt::show();
+}
diff --git a/examples/lines3d.png b/examples/lines3d.png
new file mode 100644
index 0000000..7a0c478
Binary files /dev/null and b/examples/lines3d.png differ
diff --git a/examples/minimal.png b/examples/minimal.png
index bbb79aa..0f6cf37 100644
Binary files a/examples/minimal.png and b/examples/minimal.png differ
diff --git a/examples/modern.cpp b/examples/modern.cpp
index a8aa0c7..871ef2b 100644
--- a/examples/modern.cpp
+++ b/examples/modern.cpp
@@ -24,6 +24,9 @@ int main()
 	// y must either be callable (providing operator() const) or iterable. 
 	plt::plot(x, y, "r-", x, [](double d) { return 12.5+abs(sin(d)); }, "k-");
 
+	//plt::set_aspect(0.5);
+	plt::set_aspect_equal();
+
 
 	// show plots
 	plt::show();
diff --git a/examples/nonblock.cpp b/examples/nonblock.cpp
new file mode 100644
index 0000000..327d96c
--- /dev/null
+++ b/examples/nonblock.cpp
@@ -0,0 +1,46 @@
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include "../matplotlibcpp.h"
+
+namespace plt = matplotlibcpp;
+
+
+using namespace matplotlibcpp;
+using namespace std;
+
+int main()
+{
+    // Prepare data.
+    int n = 5000;
+    std::vector<double> x(n), y(n), z(n), w(n,2);
+    for(int i=0; i<n; ++i) {
+        x.at(i) = i*i;
+        y.at(i) = sin(2*M_PI*i/360.0);
+        z.at(i) = log(i);
+    }
+
+    // Plot line from given x and y data. Color is selected automatically.
+    plt::subplot(2,2,1);
+    plt::plot(x, y);
+
+    // Plot a red dashed line from given x and y data.
+    plt::subplot(2,2,2);
+    plt::plot(x, w,"r--");
+
+    // Plot a line whose name will show up as "log(x)" in the legend.
+    plt::subplot(2,2,3);
+    plt::named_plot("log(x)", x, z);
+
+    // Set x-axis to interval [0,1000000]
+    plt::xlim(0, 1000*1000);
+
+    // Add graph title
+    plt::title("Sample figure");
+    // Enable legend.
+    plt::legend();
+
+    plt::show(false);
+
+    cout << "matplotlibcpp::show() is working in an non-blocking mode" << endl;
+    getchar();
+}
diff --git a/examples/quiver.cpp b/examples/quiver.cpp
new file mode 100644
index 0000000..ea3c3ec
--- /dev/null
+++ b/examples/quiver.cpp
@@ -0,0 +1,20 @@
+#include "../matplotlibcpp.h"
+
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    // u and v are respectively the x and y components of the arrows we're plotting
+    std::vector<int> x, y, u, v;
+    for (int i = -5; i <= 5; i++) {
+        for (int j = -5; j <= 5; j++) {
+            x.push_back(i);
+            u.push_back(-i);
+            y.push_back(j);
+            v.push_back(-j);
+        }
+    }
+
+    plt::quiver(x, y, u, v);
+    plt::show();
+}
\ No newline at end of file
diff --git a/examples/quiver.png b/examples/quiver.png
new file mode 100644
index 0000000..9d7be1e
Binary files /dev/null and b/examples/quiver.png differ
diff --git a/examples/spy.cpp b/examples/spy.cpp
new file mode 100644
index 0000000..6027a48
--- /dev/null
+++ b/examples/spy.cpp
@@ -0,0 +1,30 @@
+#include "../matplotlibcpp.h"
+
+#include <iostream>
+#include <vector>
+
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    const int n = 20;
+    std::vector<std::vector<double>> matrix;
+
+    for (int i = 0; i < n; ++i) {
+        std::vector<double> row;
+        for (int j = 0; j < n; ++j) {
+            if (i == j)
+                row.push_back(-2);
+            else if (j == i - 1 || j == i + 1)
+                row.push_back(1);
+            else
+                row.push_back(0);
+        }
+        matrix.push_back(row);
+    }
+
+    plt::spy(matrix, 5, {{"marker", "o"}});
+    plt::show();
+
+    return 0;
+}
diff --git a/examples/subplot.cpp b/examples/subplot.cpp
new file mode 100644
index 0000000..bee322e
--- /dev/null
+++ b/examples/subplot.cpp
@@ -0,0 +1,31 @@
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include "../matplotlibcpp.h"
+
+using namespace std;
+namespace plt = matplotlibcpp;
+
+int main() 
+{
+    // Prepare data
+	int n = 500;
+	std::vector<double> x(n), y(n), z(n), w(n,2);
+	for(int i=0; i<n; ++i) {
+		x.at(i) = i;
+		y.at(i) = sin(2*M_PI*i/360.0);
+		z.at(i) = 100.0 / i;
+	}
+
+    // Set the "super title"
+    plt::suptitle("My plot");
+    plt::subplot(1, 2, 1);
+	plt::plot(x, y, "r-");
+    plt::subplot(1, 2, 2);
+    plt::plot(x, z, "k-");
+    // Add some text to the plot
+    plt::text(100, 90, "Hello!");
+
+
+	// Show plots
+	plt::show();
+}
diff --git a/examples/subplot2grid.cpp b/examples/subplot2grid.cpp
new file mode 100644
index 0000000..f590e51
--- /dev/null
+++ b/examples/subplot2grid.cpp
@@ -0,0 +1,44 @@
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include "../matplotlibcpp.h"
+
+using namespace std;
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    // Prepare data
+	int n = 500;
+	std::vector<double> x(n), u(n), v(n), w(n);
+	for(int i=0; i<n; ++i) {
+		x.at(i) = i;
+		u.at(i) = sin(2*M_PI*i/500.0);
+		v.at(i) = 100.0 / i;
+		w.at(i) = sin(2*M_PI*i/1000.0);
+	}
+
+    // Set the "super title"
+    plt::suptitle("My plot");
+
+    const long nrows=3, ncols=3;
+    long row = 2, col = 2;
+
+    plt::subplot2grid(nrows, ncols, row, col);
+	plt::plot(x, w, "g-");
+
+    long spanr = 1, spanc = 2;
+    col = 0;
+    plt::subplot2grid(nrows, ncols, row, col, spanr, spanc);
+	plt::plot(x, v, "r-");
+
+    spanr = 2, spanc = 3;
+    row = 0, col = 0;
+    plt::subplot2grid(nrows, ncols, row, col, spanr, spanc);
+    plt::plot(x, u, "b-");
+    // Add some text to the plot
+    plt::text(100., -0.5, "Hello!");
+
+
+    // Show plots
+	plt::show();
+}
diff --git a/examples/surface.cpp b/examples/surface.cpp
new file mode 100644
index 0000000..4865f06
--- /dev/null
+++ b/examples/surface.cpp
@@ -0,0 +1,24 @@
+#include "../matplotlibcpp.h"
+
+#include <cmath>
+
+namespace plt = matplotlibcpp;
+
+int main()
+{
+    std::vector<std::vector<double>> x, y, z;
+    for (double i = -5; i <= 5;  i += 0.25) {
+        std::vector<double> x_row, y_row, z_row;
+        for (double j = -5; j <= 5; j += 0.25) {
+            x_row.push_back(i);
+            y_row.push_back(j);
+            z_row.push_back(::std::sin(::std::hypot(i, j)));
+        }
+        x.push_back(x_row);
+        y.push_back(y_row);
+        z.push_back(z_row);
+    }
+
+    plt::plot_surface(x, y, z);
+    plt::show();
+}
diff --git a/examples/surface.png b/examples/surface.png
new file mode 100644
index 0000000..6fc5fc7
Binary files /dev/null and b/examples/surface.png differ
diff --git a/examples/update.cpp b/examples/update.cpp
new file mode 100644
index 0000000..64f4906
--- /dev/null
+++ b/examples/update.cpp
@@ -0,0 +1,60 @@
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include "../matplotlibcpp.h"
+#include <chrono>
+
+namespace plt = matplotlibcpp;
+
+void update_window(const double x, const double y, const double t,
+                   std::vector<double> &xt, std::vector<double> &yt)
+{
+    const double target_length = 300;
+    const double half_win = (target_length/(2.*sqrt(1.+t*t)));
+
+    xt[0] = x - half_win;
+    xt[1] = x + half_win;
+    yt[0] = y - half_win*t;
+    yt[1] = y + half_win*t;
+}
+
+
+int main()
+{
+    size_t n = 1000;
+    std::vector<double> x, y;
+
+    const double w = 0.05;
+    const double a = n/2;
+
+    for (size_t i=0; i<n; i++) {
+        x.push_back(i);
+        y.push_back(a*sin(w*i));
+    }
+
+    std::vector<double> xt(2), yt(2);
+
+    plt::title("Tangent of a sine curve");
+    plt::xlim(x.front(), x.back());
+    plt::ylim(-a, a);
+    plt::axis("equal");
+
+    // Plot sin once and for all.
+    plt::named_plot("sin", x, y);
+
+    // Prepare plotting the tangent.
+    plt::Plot plot("tangent");
+
+    plt::legend();
+
+    for (size_t i=0; i<n; i++) {
+        if (i % 10 == 0) {
+            update_window(x[i], y[i], a*w*cos(w*x[i]), xt, yt);
+
+            // Just update data for this plot.
+            plot.update(xt, yt);
+
+            // Small pause so the viewer has a chance to enjoy the animation.
+            plt::pause(0.1);
+        }
+   }
+}
diff --git a/examples/xkcd.cpp b/examples/xkcd.cpp
new file mode 100644
index 0000000..fa41cfc
--- /dev/null
+++ b/examples/xkcd.cpp
@@ -0,0 +1,22 @@
+#define _USE_MATH_DEFINES
+#include <cmath>
+#include "../matplotlibcpp.h"
+#include <vector>
+
+namespace plt = matplotlibcpp;
+
+int main() {
+    std::vector<double> t(1000);
+    std::vector<double> x(t.size());
+
+    for(size_t i = 0; i < t.size(); i++) {
+        t[i] = i / 100.0;
+        x[i] = sin(2.0 * M_PI * 1.0 * t[i]);
+    }
+
+    plt::xkcd();
+    plt::plot(t, x);
+    plt::title("AN ORDINARY SIN WAVE");
+    plt::show();
+}
+
diff --git a/examples/xkcd.png b/examples/xkcd.png
new file mode 100644
index 0000000..c285e3d
Binary files /dev/null and b/examples/xkcd.png differ
diff --git a/matplotlibcpp.h b/matplotlibcpp.h
index 580f94b..d95d46a 100644
--- a/matplotlibcpp.h
+++ b/matplotlibcpp.h
@@ -1,825 +1,2986 @@
 #pragma once
 
+// Python headers must be included before any system headers, since
+// they define _POSIX_C_SOURCE
+#include <Python.h>
+
 #include <vector>
 #include <map>
+#include <array>
 #include <numeric>
 #include <algorithm>
 #include <stdexcept>
 #include <iostream>
-#include <stdint.h> // <cstdint> requires c++11 support
-
-#if __cplusplus > 199711L || _MSC_VER > 1800
+#include <cstdint> // <cstdint> requires c++11 support
 #include <functional>
-#endif
-
-#include <Python.h>
+#include <string> // std::stod
 
 #ifndef WITHOUT_NUMPY
-  #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
-  #include <numpy/arrayobject.h>
+#  define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#  include <numpy/arrayobject.h>
+
+#  ifdef WITH_OPENCV
+#    include <opencv2/opencv.hpp>
+#  endif // WITH_OPENCV
+
+/*
+ * A bunch of constants were removed in OpenCV 4 in favour of enum classes, so
+ * define the ones we need here.
+ */
+#  if CV_MAJOR_VERSION > 3
+#    define CV_BGR2RGB cv::COLOR_BGR2RGB
+#    define CV_BGRA2RGBA cv::COLOR_BGRA2RGBA
+#  endif
 #endif // WITHOUT_NUMPY
 
 #if PY_MAJOR_VERSION >= 3
-#define PyString_FromString PyUnicode_FromString
+#  define PyString_FromString PyUnicode_FromString
+#  define PyInt_FromLong PyLong_FromLong
+#  define PyString_FromString PyUnicode_FromString
 #endif
 
 
 namespace matplotlibcpp {
+namespace detail {
+
+static std::string s_backend;
+
+struct _interpreter {
+    PyObject* s_python_function_arrow;
+    PyObject *s_python_function_show;
+    PyObject *s_python_function_close;
+    PyObject *s_python_function_draw;
+    PyObject *s_python_function_pause;
+    PyObject *s_python_function_save;
+    PyObject *s_python_function_figure;
+    PyObject *s_python_function_fignum_exists;
+    PyObject *s_python_function_plot;
+    PyObject *s_python_function_quiver;
+    PyObject* s_python_function_contour;
+    PyObject *s_python_function_semilogx;
+    PyObject *s_python_function_semilogy;
+    PyObject *s_python_function_loglog;
+    PyObject *s_python_function_fill;
+    PyObject *s_python_function_fill_between;
+    PyObject *s_python_function_hist;
+    PyObject *s_python_function_imshow;
+    PyObject *s_python_function_scatter;
+    PyObject *s_python_function_boxplot;
+    PyObject *s_python_function_subplot;
+    PyObject *s_python_function_subplot2grid;
+    PyObject *s_python_function_legend;
+    PyObject *s_python_function_xlim;
+    PyObject *s_python_function_ion;
+    PyObject *s_python_function_ginput;
+    PyObject *s_python_function_ylim;
+    PyObject *s_python_function_title;
+    PyObject *s_python_function_axis;
+    PyObject *s_python_function_axhline;
+    PyObject *s_python_function_axvline;
+    PyObject *s_python_function_axvspan;
+    PyObject *s_python_function_xlabel;
+    PyObject *s_python_function_ylabel;
+    PyObject *s_python_function_gca;
+    PyObject *s_python_function_xticks;
+    PyObject *s_python_function_yticks;
+    PyObject* s_python_function_margins;
+    PyObject *s_python_function_tick_params;
+    PyObject *s_python_function_grid;
+    PyObject* s_python_function_cla;
+    PyObject *s_python_function_clf;
+    PyObject *s_python_function_errorbar;
+    PyObject *s_python_function_annotate;
+    PyObject *s_python_function_tight_layout;
+    PyObject *s_python_colormap;
+    PyObject *s_python_empty_tuple;
+    PyObject *s_python_function_stem;
+    PyObject *s_python_function_xkcd;
+    PyObject *s_python_function_text;
+    PyObject *s_python_function_suptitle;
+    PyObject *s_python_function_bar;
+    PyObject *s_python_function_barh;
+    PyObject *s_python_function_colorbar;
+    PyObject *s_python_function_subplots_adjust;
+    PyObject *s_python_function_rcparams;
+    PyObject *s_python_function_spy;
+
+    /* For now, _interpreter is implemented as a singleton since its currently not possible to have
+       multiple independent embedded python interpreters without patching the python source code
+       or starting a separate process for each. [1]
+       Furthermore, many python objects expect that they are destructed in the same thread as they
+       were constructed. [2] So for advanced usage, a `kill()` function is provided so that library
+       users can manually ensure that the interpreter is constructed and destroyed within the
+       same thread.
+
+         1: http://bytes.com/topic/python/answers/793370-multiple-independent-python-interpreters-c-c-program
+         2: https://github.com/lava/matplotlib-cpp/pull/202#issue-436220256
+       */
+
+    static _interpreter& get() {
+        return interkeeper(false);
+    }
+
+    static _interpreter& kill() {
+        return interkeeper(true);
+    }
+
+    // Stores the actual singleton object referenced by `get()` and `kill()`.
+    static _interpreter& interkeeper(bool should_kill) {
+        static _interpreter ctx;
+        if (should_kill)
+            ctx.~_interpreter();
+        return ctx;
+    }
+
+    PyObject* safe_import(PyObject* module, std::string fname) {
+        PyObject* fn = PyObject_GetAttrString(module, fname.c_str());
+
+        if (!fn)
+            throw std::runtime_error(std::string("Couldn't find required function: ") + fname);
+
+        if (!PyFunction_Check(fn))
+            throw std::runtime_error(fname + std::string(" is unexpectedly not a PyFunction."));
+
+        return fn;
+    }
+
+private:
+
+#ifndef WITHOUT_NUMPY
+#  if PY_MAJOR_VERSION >= 3
+
+    void *import_numpy() {
+        import_array(); // initialize C-API
+        return NULL;
+    }
+
+#  else
+
+    void import_numpy() {
+        import_array(); // initialize C-API
+    }
+
+#  endif
+#endif
+
+    _interpreter() {
 
-	namespace detail {
-		static std::string s_backend;
-
-		struct _interpreter {
-			PyObject *s_python_function_show;
-			PyObject *s_python_function_save;
-			PyObject *s_python_function_figure;
-			PyObject *s_python_function_plot;
-			PyObject *s_python_function_fill_between;
-			PyObject *s_python_function_hist;
-			PyObject *s_python_function_subplot;
-			PyObject *s_python_function_legend;
-			PyObject *s_python_function_xlim;
-			PyObject *s_python_function_ylim;
-			PyObject *s_python_function_title;
-			PyObject *s_python_function_axis;
-			PyObject *s_python_function_xlabel;
-			PyObject *s_python_function_ylabel;
-			PyObject *s_python_function_grid;
-			PyObject *s_python_function_clf;
-			PyObject *s_python_function_errorbar;
-			PyObject *s_python_function_annotate;
-			PyObject *s_python_function_tight_layout;
-			PyObject *s_python_empty_tuple;
-
-			/* For now, _interpreter is implemented as a singleton since its currently not possible to have
-			   multiple independent embedded python interpreters without patching the python source code
-			   or starting a separate process for each.
-				http://bytes.com/topic/python/answers/793370-multiple-independent-python-interpreters-c-c-program
-			   */
-
-			static _interpreter& get() {
-				static _interpreter ctx;
-				return ctx;
-			}
-
-			private:
-			_interpreter() {
-                
-                // optional but recommended
+        // optional but recommended
 #if PY_MAJOR_VERSION >= 3
-				wchar_t name[] = L"plotting";
+        wchar_t name[] = L"plotting";
 #else
-				char name[] = "plotting";
+        char name[] = "plotting";
+#endif
+        Py_SetProgramName(name);
+        Py_Initialize();
+
+        wchar_t const *dummy_args[] = {L"Python", NULL};  // const is needed because literals must not be modified
+        wchar_t const **argv = dummy_args;
+        int             argc = sizeof(dummy_args)/sizeof(dummy_args[0])-1;
+
+#if PY_MAJOR_VERSION >= 3
+        PySys_SetArgv(argc, const_cast<wchar_t **>(argv));
+#else
+        PySys_SetArgv(argc, (char **)(argv));
 #endif
-				Py_SetProgramName(name);
-				Py_Initialize();
 
 #ifndef WITHOUT_NUMPY
-				import_array(); // initialize numpy C-API
+        import_numpy(); // initialize numpy C-API
 #endif
 
-				PyObject* matplotlibname = PyString_FromString("matplotlib");
-				PyObject* pyplotname = PyString_FromString("matplotlib.pyplot");
-				PyObject* pylabname  = PyString_FromString("pylab");
-				if (!pyplotname || !pylabname || !matplotlibname) {
-					throw std::runtime_error("couldnt create string");
-				}
-
-				PyObject* matplotlib = PyImport_Import(matplotlibname);
-				Py_DECREF(matplotlibname);
-				if(!matplotlib) { throw std::runtime_error("Error loading module matplotlib!"); }
-
-				// matplotlib.use() must be called *before* pylab, matplotlib.pyplot,
-				// or matplotlib.backends is imported for the first time
-				if (!s_backend.empty()) {
-					PyObject_CallMethod(matplotlib, "use", "s", s_backend.c_str());
-				}
-
-				PyObject* pymod = PyImport_Import(pyplotname);
-				Py_DECREF(pyplotname);
-				if(!pymod) { throw std::runtime_error("Error loading module matplotlib.pyplot!"); }
-
-
-				PyObject* pylabmod = PyImport_Import(pylabname);
-				Py_DECREF(pylabname);
-				if(!pylabmod) { throw std::runtime_error("Error loading module pylab!"); }
-
-				s_python_function_show = PyObject_GetAttrString(pymod, "show");
-				s_python_function_figure = PyObject_GetAttrString(pymod, "figure");
-				s_python_function_plot = PyObject_GetAttrString(pymod, "plot");
-				s_python_function_fill_between = PyObject_GetAttrString(pymod, "fill_between");
-				s_python_function_hist = PyObject_GetAttrString(pymod,"hist");
-				s_python_function_subplot = PyObject_GetAttrString(pymod, "subplot");
-				s_python_function_legend = PyObject_GetAttrString(pymod, "legend");
-				s_python_function_ylim = PyObject_GetAttrString(pymod, "ylim");
-				s_python_function_title = PyObject_GetAttrString(pymod, "title");
-				s_python_function_axis = PyObject_GetAttrString(pymod, "axis");
-				s_python_function_xlabel = PyObject_GetAttrString(pymod, "xlabel");
-				s_python_function_ylabel = PyObject_GetAttrString(pymod, "ylabel");
-				s_python_function_grid = PyObject_GetAttrString(pymod, "grid");
-				s_python_function_xlim = PyObject_GetAttrString(pymod, "xlim");
-				s_python_function_save = PyObject_GetAttrString(pylabmod, "savefig");
-				s_python_function_annotate = PyObject_GetAttrString(pymod,"annotate");
-				s_python_function_clf = PyObject_GetAttrString(pymod, "clf");
-				s_python_function_errorbar = PyObject_GetAttrString(pymod, "errorbar");
-				s_python_function_tight_layout = PyObject_GetAttrString(pymod, "tight_layout");
-
-				if(        !s_python_function_show
-					|| !s_python_function_figure
-					|| !s_python_function_plot
-					|| !s_python_function_fill_between
-					|| !s_python_function_subplot
-				   	|| !s_python_function_legend
-					|| !s_python_function_ylim
-					|| !s_python_function_title
-					|| !s_python_function_axis
-					|| !s_python_function_xlabel
-					|| !s_python_function_ylabel
-					|| !s_python_function_grid
-					|| !s_python_function_xlim
-					|| !s_python_function_save
-					|| !s_python_function_clf
-					|| !s_python_function_annotate
-					|| !s_python_function_errorbar
-					|| !s_python_function_errorbar
-					|| !s_python_function_tight_layout
-				) { throw std::runtime_error("Couldn't find required function!"); }
-
-				if (       !PyFunction_Check(s_python_function_show)
-					|| !PyFunction_Check(s_python_function_figure)
-					|| !PyFunction_Check(s_python_function_plot)
-					|| !PyFunction_Check(s_python_function_fill_between)
-					|| !PyFunction_Check(s_python_function_subplot)
-					|| !PyFunction_Check(s_python_function_legend)
-					|| !PyFunction_Check(s_python_function_annotate)
-					|| !PyFunction_Check(s_python_function_ylim)
-					|| !PyFunction_Check(s_python_function_title)
-					|| !PyFunction_Check(s_python_function_axis)
-					|| !PyFunction_Check(s_python_function_xlabel)
-					|| !PyFunction_Check(s_python_function_ylabel)
-					|| !PyFunction_Check(s_python_function_grid)
-					|| !PyFunction_Check(s_python_function_xlim)
-					|| !PyFunction_Check(s_python_function_save)
-					|| !PyFunction_Check(s_python_function_clf)
-					|| !PyFunction_Check(s_python_function_tight_layout)
-					|| !PyFunction_Check(s_python_function_errorbar)
-				) { throw std::runtime_error("Python object is unexpectedly not a PyFunction."); }
-
-				s_python_empty_tuple = PyTuple_New(0);
-			}
-
-			~_interpreter() {
-				Py_Finalize();
-			}
-		};
-	}
-
-	// must be called before the first regular call to matplotlib to have any effect
-	void backend(const std::string& name)
-	{
-		detail::s_backend = name;
-	}
-  
-	bool annotate(std::string annotation, double x, double y)
-	{
-		PyObject * xy = PyTuple_New(2);
-		PyObject * str = PyString_FromString(annotation.c_str());
+        PyObject* matplotlibname = PyString_FromString("matplotlib");
+        PyObject* pyplotname = PyString_FromString("matplotlib.pyplot");
+        PyObject* cmname  = PyString_FromString("matplotlib.cm");
+        PyObject* pylabname  = PyString_FromString("pylab");
+        if (!pyplotname || !pylabname || !matplotlibname || !cmname) {
+            throw std::runtime_error("couldnt create string");
+        }
+
+        PyObject* matplotlib = PyImport_Import(matplotlibname);
+
+        Py_DECREF(matplotlibname);
+        if (!matplotlib) {
+            PyErr_Print();
+            throw std::runtime_error("Error loading module matplotlib!");
+        }
+
+        // matplotlib.use() must be called *before* pylab, matplotlib.pyplot,
+        // or matplotlib.backends is imported for the first time
+        if (!s_backend.empty()) {
+            PyObject_CallMethod(matplotlib, const_cast<char*>("use"), const_cast<char*>("s"), s_backend.c_str());
+        }
+
+
+
+        PyObject* pymod = PyImport_Import(pyplotname);
+        Py_DECREF(pyplotname);
+        if (!pymod) { throw std::runtime_error("Error loading module matplotlib.pyplot!"); }
+
+        s_python_colormap = PyImport_Import(cmname);
+        Py_DECREF(cmname);
+        if (!s_python_colormap) { throw std::runtime_error("Error loading module matplotlib.cm!"); }
+
+        PyObject* pylabmod = PyImport_Import(pylabname);
+        Py_DECREF(pylabname);
+        if (!pylabmod) { throw std::runtime_error("Error loading module pylab!"); }
+
+        s_python_function_arrow = safe_import(pymod, "arrow");
+        s_python_function_show = safe_import(pymod, "show");
+        s_python_function_close = safe_import(pymod, "close");
+        s_python_function_draw = safe_import(pymod, "draw");
+        s_python_function_pause = safe_import(pymod, "pause");
+        s_python_function_figure = safe_import(pymod, "figure");
+        s_python_function_fignum_exists = safe_import(pymod, "fignum_exists");
+        s_python_function_plot = safe_import(pymod, "plot");
+        s_python_function_quiver = safe_import(pymod, "quiver");
+        s_python_function_contour = safe_import(pymod, "contour");
+        s_python_function_semilogx = safe_import(pymod, "semilogx");
+        s_python_function_semilogy = safe_import(pymod, "semilogy");
+        s_python_function_loglog = safe_import(pymod, "loglog");
+        s_python_function_fill = safe_import(pymod, "fill");
+        s_python_function_fill_between = safe_import(pymod, "fill_between");
+        s_python_function_hist = safe_import(pymod,"hist");
+        s_python_function_scatter = safe_import(pymod,"scatter");
+        s_python_function_boxplot = safe_import(pymod,"boxplot");
+        s_python_function_subplot = safe_import(pymod, "subplot");
+        s_python_function_subplot2grid = safe_import(pymod, "subplot2grid");
+        s_python_function_legend = safe_import(pymod, "legend");
+        s_python_function_xlim = safe_import(pymod, "xlim");
+        s_python_function_ylim = safe_import(pymod, "ylim");
+        s_python_function_title = safe_import(pymod, "title");
+        s_python_function_axis = safe_import(pymod, "axis");
+        s_python_function_axhline = safe_import(pymod, "axhline");
+        s_python_function_axvline = safe_import(pymod, "axvline");
+        s_python_function_axvspan = safe_import(pymod, "axvspan");
+        s_python_function_xlabel = safe_import(pymod, "xlabel");
+        s_python_function_ylabel = safe_import(pymod, "ylabel");
+        s_python_function_gca = safe_import(pymod, "gca");
+        s_python_function_xticks = safe_import(pymod, "xticks");
+        s_python_function_yticks = safe_import(pymod, "yticks");
+        s_python_function_margins = safe_import(pymod, "margins");
+        s_python_function_tick_params = safe_import(pymod, "tick_params");
+        s_python_function_grid = safe_import(pymod, "grid");
+        s_python_function_ion = safe_import(pymod, "ion");
+        s_python_function_ginput = safe_import(pymod, "ginput");
+        s_python_function_save = safe_import(pylabmod, "savefig");
+        s_python_function_annotate = safe_import(pymod,"annotate");
+        s_python_function_cla = safe_import(pymod, "cla");
+        s_python_function_clf = safe_import(pymod, "clf");
+        s_python_function_errorbar = safe_import(pymod, "errorbar");
+        s_python_function_tight_layout = safe_import(pymod, "tight_layout");
+        s_python_function_stem = safe_import(pymod, "stem");
+        s_python_function_xkcd = safe_import(pymod, "xkcd");
+        s_python_function_text = safe_import(pymod, "text");
+        s_python_function_suptitle = safe_import(pymod, "suptitle");
+        s_python_function_bar = safe_import(pymod,"bar");
+        s_python_function_barh = safe_import(pymod, "barh");
+        s_python_function_colorbar = PyObject_GetAttrString(pymod, "colorbar");
+        s_python_function_subplots_adjust = safe_import(pymod,"subplots_adjust");
+        s_python_function_rcparams = PyObject_GetAttrString(pymod, "rcParams");
+	s_python_function_spy = PyObject_GetAttrString(pymod, "spy");
+#ifndef WITHOUT_NUMPY
+        s_python_function_imshow = safe_import(pymod, "imshow");
+#endif
+        s_python_empty_tuple = PyTuple_New(0);
+    }
+
+    ~_interpreter() {
+        Py_Finalize();
+    }
+};
+
+} // end namespace detail
+
+/// Select the backend
+///
+/// **NOTE:** This must be called before the first plot command to have
+/// any effect.
+///
+/// Mainly useful to select the non-interactive 'Agg' backend when running
+/// matplotlibcpp in headless mode, for example on a machine with no display.
+///
+/// See also: https://matplotlib.org/2.0.2/api/matplotlib_configuration_api.html#matplotlib.use
+inline void backend(const std::string& name)
+{
+    detail::s_backend = name;
+}
+
+inline bool annotate(std::string annotation, double x, double y)
+{
+    detail::_interpreter::get();
+
+    PyObject * xy = PyTuple_New(2);
+    PyObject * str = PyString_FromString(annotation.c_str());
 
-		PyTuple_SetItem(xy,0,PyFloat_FromDouble(x));
-		PyTuple_SetItem(xy,1,PyFloat_FromDouble(y));
+    PyTuple_SetItem(xy,0,PyFloat_FromDouble(x));
+    PyTuple_SetItem(xy,1,PyFloat_FromDouble(y));
 
-		PyObject* kwargs = PyDict_New();
-		PyDict_SetItemString(kwargs, "xy", xy);
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "xy", xy);
 
-		PyObject* args = PyTuple_New(1);
-		PyTuple_SetItem(args, 0, str);
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, str);
 
-		PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_annotate, args, kwargs);
-		
-		Py_DECREF(args);
-		Py_DECREF(kwargs);
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_annotate, args, kwargs);
 
-		if(res) Py_DECREF(res);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+
+    if(res) Py_DECREF(res);
+
+    return res;
+}
 
-		return res;
-	}
+namespace detail {
 
 #ifndef WITHOUT_NUMPY
-	// Type selector for numpy array conversion
-	template <typename T> struct select_npy_type { const static NPY_TYPES type = NPY_NOTYPE; }; //Default
-	template <> struct select_npy_type<double> { const static NPY_TYPES type = NPY_DOUBLE; };
-	template <> struct select_npy_type<float> { const static NPY_TYPES type = NPY_FLOAT; };
-	template <> struct select_npy_type<bool> { const static NPY_TYPES type = NPY_BOOL; };
-	template <> struct select_npy_type<int8_t> { const static NPY_TYPES type = NPY_INT8; };
-	template <> struct select_npy_type<int16_t> { const static NPY_TYPES type = NPY_SHORT; };
-	template <> struct select_npy_type<int32_t> { const static NPY_TYPES type = NPY_INT; };
-	template <> struct select_npy_type<int64_t> { const static NPY_TYPES type = NPY_INT64; };
-	template <> struct select_npy_type<uint8_t> { const static NPY_TYPES type = NPY_UINT8; };
-	template <> struct select_npy_type<uint16_t> { const static NPY_TYPES type = NPY_USHORT; };
-	template <> struct select_npy_type<uint32_t> { const static NPY_TYPES type = NPY_ULONG; };
-	template <> struct select_npy_type<uint64_t> { const static NPY_TYPES type = NPY_UINT64; };
-
-	template<typename Numeric>
-	PyObject* get_array(const std::vector<Numeric>& v)
-	{
-		detail::_interpreter::get();	//interpreter needs to be initialized for the numpy commands to work
-		NPY_TYPES type = select_npy_type<Numeric>::type; 
-		if (type == NPY_NOTYPE)
-		{
-			std::vector<double> vd(v.size());
-			npy_intp vsize = v.size();
-			std::copy(v.begin(),v.end(),vd.begin());
-			PyObject* varray = PyArray_SimpleNewFromData(1, &vsize, NPY_DOUBLE, (void*)(vd.data()));
-			return varray;
-		}
-
-		npy_intp vsize = v.size();
-		PyObject* varray = PyArray_SimpleNewFromData(1, &vsize, type, (void*)(v.data()));
-		return varray;
-	}
+// Type selector for numpy array conversion
+template <typename T> struct select_npy_type { const static NPY_TYPES type = NPY_NOTYPE; }; //Default
+template <> struct select_npy_type<double> { const static NPY_TYPES type = NPY_DOUBLE; };
+template <> struct select_npy_type<float> { const static NPY_TYPES type = NPY_FLOAT; };
+template <> struct select_npy_type<bool> { const static NPY_TYPES type = NPY_BOOL; };
+template <> struct select_npy_type<int8_t> { const static NPY_TYPES type = NPY_INT8; };
+template <> struct select_npy_type<int16_t> { const static NPY_TYPES type = NPY_SHORT; };
+template <> struct select_npy_type<int32_t> { const static NPY_TYPES type = NPY_INT; };
+template <> struct select_npy_type<int64_t> { const static NPY_TYPES type = NPY_INT64; };
+template <> struct select_npy_type<uint8_t> { const static NPY_TYPES type = NPY_UINT8; };
+template <> struct select_npy_type<uint16_t> { const static NPY_TYPES type = NPY_USHORT; };
+template <> struct select_npy_type<uint32_t> { const static NPY_TYPES type = NPY_ULONG; };
+template <> struct select_npy_type<uint64_t> { const static NPY_TYPES type = NPY_UINT64; };
+
+// Sanity checks; comment them out or change the numpy type below if you're compiling on
+// a platform where they don't apply
+static_assert(sizeof(long long) == 8);
+template <> struct select_npy_type<long long> { const static NPY_TYPES type = NPY_INT64; };
+static_assert(sizeof(unsigned long long) == 8);
+template <> struct select_npy_type<unsigned long long> { const static NPY_TYPES type = NPY_UINT64; };
+
+template<typename Numeric>
+PyObject* get_array(const std::vector<Numeric>& v)
+{
+    npy_intp vsize = v.size();
+    NPY_TYPES type = select_npy_type<Numeric>::type;
+    if (type == NPY_NOTYPE) {
+        size_t memsize = v.size()*sizeof(double);
+        double* dp = static_cast<double*>(::malloc(memsize));
+        for (size_t i=0; i<v.size(); ++i)
+            dp[i] = v[i];
+        PyObject* varray = PyArray_SimpleNewFromData(1, &vsize, NPY_DOUBLE, dp);
+        PyArray_UpdateFlags(reinterpret_cast<PyArrayObject*>(varray), NPY_ARRAY_OWNDATA);
+        return varray;
+    }
+
+    PyObject* varray = PyArray_SimpleNewFromData(1, &vsize, type, (void*)(v.data()));
+    return varray;
+}
+
+
+template<typename Numeric>
+PyObject* get_2darray(const std::vector<::std::vector<Numeric>>& v)
+{
+    if (v.size() < 1) throw std::runtime_error("get_2d_array v too small");
+
+    npy_intp vsize[2] = {static_cast<npy_intp>(v.size()),
+                         static_cast<npy_intp>(v[0].size())};
+
+    PyArrayObject *varray =
+        (PyArrayObject *)PyArray_SimpleNew(2, vsize, NPY_DOUBLE);
+
+    double *vd_begin = static_cast<double *>(PyArray_DATA(varray));
+
+    for (const ::std::vector<Numeric> &v_row : v) {
+      if (v_row.size() != static_cast<size_t>(vsize[1]))
+        throw std::runtime_error("Missmatched array size");
+      std::copy(v_row.begin(), v_row.end(), vd_begin);
+      vd_begin += vsize[1];
+    }
+
+    return reinterpret_cast<PyObject *>(varray);
+}
 
 #else // fallback if we don't have numpy: copy every element of the given vector
 
-	template<typename Numeric>
-	PyObject* get_array(const std::vector<Numeric>& v)
-	{
-		PyObject* list = PyList_New(v.size());
-		for(size_t i = 0; i < v.size(); ++i) {
-			PyList_SetItem(list, i, PyFloat_FromDouble(v.at(i)));
-		}
-		return list;
-	}
+template<typename Numeric>
+PyObject* get_array(const std::vector<Numeric>& v)
+{
+    PyObject* list = PyList_New(v.size());
+    for(size_t i = 0; i < v.size(); ++i) {
+        PyList_SetItem(list, i, PyFloat_FromDouble(v.at(i)));
+    }
+    return list;
+}
+
+#endif // WITHOUT_NUMPY
+
+// sometimes, for labels and such, we need string arrays
+inline PyObject * get_array(const std::vector<std::string>& strings)
+{
+  PyObject* list = PyList_New(strings.size());
+  for (std::size_t i = 0; i < strings.size(); ++i) {
+    PyList_SetItem(list, i, PyString_FromString(strings[i].c_str()));
+  }
+  return list;
+}
+
+// not all matplotlib need 2d arrays, some prefer lists of lists
+template<typename Numeric>
+PyObject* get_listlist(const std::vector<std::vector<Numeric>>& ll)
+{
+  PyObject* listlist = PyList_New(ll.size());
+  for (std::size_t i = 0; i < ll.size(); ++i) {
+    PyList_SetItem(listlist, i, get_array(ll[i]));
+  }
+  return listlist;
+}
+
+} // namespace detail
+
+/// Plot a line through the given x and y data points..
+///
+/// See: https://matplotlib.org/3.2.1/api/_as_gen/matplotlib.pyplot.plot.html
+template<typename Numeric>
+bool plot(const std::vector<Numeric> &x, const std::vector<Numeric> &y, const std::map<std::string, std::string>& keywords)
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    // using numpy arrays
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    // construct positional args
+    PyObject* args = PyTuple_New(2);
+    PyTuple_SetItem(args, 0, xarray);
+    PyTuple_SetItem(args, 1, yarray);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+// TODO - it should be possible to make this work by implementing
+// a non-numpy alternative for `detail::get_2darray()`.
+#ifndef WITHOUT_NUMPY
+template <typename Numeric>
+void plot_surface(const std::vector<::std::vector<Numeric>> &x,
+                  const std::vector<::std::vector<Numeric>> &y,
+                  const std::vector<::std::vector<Numeric>> &z,
+                  const std::map<std::string, std::string> &keywords =
+                      std::map<std::string, std::string>(),
+                  const long fig_number=0)
+{
+  detail::_interpreter::get();
+
+  // We lazily load the modules here the first time this function is called
+  // because I'm not sure that we can assume "matplotlib installed" implies
+  // "mpl_toolkits installed" on all platforms, and we don't want to require
+  // it for people who don't need 3d plots.
+  static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+  if (!mpl_toolkitsmod) {
+    detail::_interpreter::get();
+
+    PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+    PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+    if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+    mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+    Py_DECREF(mpl_toolkits);
+    if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+    axis3dmod = PyImport_Import(axis3d);
+    Py_DECREF(axis3d);
+    if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+  }
+
+  assert(x.size() == y.size());
+  assert(y.size() == z.size());
+
+  // using numpy arrays
+  PyObject *xarray = detail::get_2darray(x);
+  PyObject *yarray = detail::get_2darray(y);
+  PyObject *zarray = detail::get_2darray(z);
+
+  // construct positional args
+  PyObject *args = PyTuple_New(3);
+  PyTuple_SetItem(args, 0, xarray);
+  PyTuple_SetItem(args, 1, yarray);
+  PyTuple_SetItem(args, 2, zarray);
+
+  // Build up the kw args.
+  PyObject *kwargs = PyDict_New();
+  PyDict_SetItemString(kwargs, "rstride", PyInt_FromLong(1));
+  PyDict_SetItemString(kwargs, "cstride", PyInt_FromLong(1));
+
+  PyObject *python_colormap_coolwarm = PyObject_GetAttrString(
+      detail::_interpreter::get().s_python_colormap, "coolwarm");
+
+  PyDict_SetItemString(kwargs, "cmap", python_colormap_coolwarm);
+
+  for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+       it != keywords.end(); ++it) {
+    if (it->first == "linewidth" || it->first == "alpha") {
+      PyDict_SetItemString(kwargs, it->first.c_str(),
+        PyFloat_FromDouble(std::stod(it->second)));
+    } else {
+      PyDict_SetItemString(kwargs, it->first.c_str(),
+        PyString_FromString(it->second.c_str()));
+    }
+  }
+
+  PyObject *fig_args = PyTuple_New(1);
+  PyObject* fig = nullptr;
+  PyTuple_SetItem(fig_args, 0, PyLong_FromLong(fig_number));
+  PyObject *fig_exists =
+    PyObject_CallObject(
+    detail::_interpreter::get().s_python_function_fignum_exists, fig_args);
+  if (!PyObject_IsTrue(fig_exists)) {
+    fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+      detail::_interpreter::get().s_python_empty_tuple);
+  } else {
+    fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+      fig_args);
+  }
+  Py_DECREF(fig_exists);
+  if (!fig) throw std::runtime_error("Call to figure() failed.");
+
+  PyObject *gca_kwargs = PyDict_New();
+  PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
+
+  PyObject *gca = PyObject_GetAttrString(fig, "gca");
+  if (!gca) throw std::runtime_error("No gca");
+  Py_INCREF(gca);
+  PyObject *axis = PyObject_Call(
+      gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
+
+  if (!axis) throw std::runtime_error("No axis");
+  Py_INCREF(axis);
+
+  Py_DECREF(gca);
+  Py_DECREF(gca_kwargs);
+
+  PyObject *plot_surface = PyObject_GetAttrString(axis, "plot_surface");
+  if (!plot_surface) throw std::runtime_error("No surface");
+  Py_INCREF(plot_surface);
+  PyObject *res = PyObject_Call(plot_surface, args, kwargs);
+  if (!res) throw std::runtime_error("failed surface");
+  Py_DECREF(plot_surface);
+
+  Py_DECREF(axis);
+  Py_DECREF(args);
+  Py_DECREF(kwargs);
+  if (res) Py_DECREF(res);
+}
+
+template <typename Numeric>
+void contour(const std::vector<::std::vector<Numeric>> &x,
+             const std::vector<::std::vector<Numeric>> &y,
+             const std::vector<::std::vector<Numeric>> &z,
+             const std::map<std::string, std::string> &keywords = {})
+{
+  detail::_interpreter::get();
+
+  // using numpy arrays
+  PyObject *xarray = detail::get_2darray(x);
+  PyObject *yarray = detail::get_2darray(y);
+  PyObject *zarray = detail::get_2darray(z);
+
+  // construct positional args
+  PyObject *args = PyTuple_New(3);
+  PyTuple_SetItem(args, 0, xarray);
+  PyTuple_SetItem(args, 1, yarray);
+  PyTuple_SetItem(args, 2, zarray);
+
+  // Build up the kw args.
+  PyObject *kwargs = PyDict_New();
+
+  PyObject *python_colormap_coolwarm = PyObject_GetAttrString(
+      detail::_interpreter::get().s_python_colormap, "coolwarm");
+
+  PyDict_SetItemString(kwargs, "cmap", python_colormap_coolwarm);
+
+  for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+       it != keywords.end(); ++it) {
+    PyDict_SetItemString(kwargs, it->first.c_str(),
+                         PyString_FromString(it->second.c_str()));
+  }
+
+  PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_contour, args, kwargs);
+  if (!res)
+    throw std::runtime_error("failed contour");
+
+  Py_DECREF(args);
+  Py_DECREF(kwargs);
+  if (res) Py_DECREF(res);
+}
 
+template <typename Numeric>
+void spy(const std::vector<::std::vector<Numeric>> &x,
+         const double markersize = -1,  // -1 for default matplotlib size
+         const std::map<std::string, std::string> &keywords = {})
+{
+  detail::_interpreter::get();
+
+  PyObject *xarray = detail::get_2darray(x);
+
+  PyObject *kwargs = PyDict_New();
+  if (markersize != -1) {
+    PyDict_SetItemString(kwargs, "markersize", PyFloat_FromDouble(markersize));
+  }
+  for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+       it != keywords.end(); ++it) {
+    PyDict_SetItemString(kwargs, it->first.c_str(),
+                         PyString_FromString(it->second.c_str()));
+  }
+
+  PyObject *plot_args = PyTuple_New(1);
+  PyTuple_SetItem(plot_args, 0, xarray);
+
+  PyObject *res = PyObject_Call(
+      detail::_interpreter::get().s_python_function_spy, plot_args, kwargs);
+
+  Py_DECREF(plot_args);
+  Py_DECREF(kwargs);
+  if (res) Py_DECREF(res);
+}
 #endif // WITHOUT_NUMPY
 
-	template<typename Numeric>
-	bool plot(const std::vector<Numeric> &x, const std::vector<Numeric> &y, const std::map<std::string, std::string>& keywords)
-	{
-		assert(x.size() == y.size());
+template <typename Numeric>
+void plot3(const std::vector<Numeric> &x,
+                  const std::vector<Numeric> &y,
+                  const std::vector<Numeric> &z,
+                  const std::map<std::string, std::string> &keywords =
+                      std::map<std::string, std::string>(),
+                  const long fig_number=0)
+{
+  detail::_interpreter::get();
+
+  // Same as with plot_surface: We lazily load the modules here the first time
+  // this function is called because I'm not sure that we can assume "matplotlib
+  // installed" implies "mpl_toolkits installed" on all platforms, and we don't
+  // want to require it for people who don't need 3d plots.
+  static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+  if (!mpl_toolkitsmod) {
+    detail::_interpreter::get();
+
+    PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+    PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+    if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+    mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+    Py_DECREF(mpl_toolkits);
+    if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+    axis3dmod = PyImport_Import(axis3d);
+    Py_DECREF(axis3d);
+    if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+  }
+
+  assert(x.size() == y.size());
+  assert(y.size() == z.size());
+
+  PyObject *xarray = detail::get_array(x);
+  PyObject *yarray = detail::get_array(y);
+  PyObject *zarray = detail::get_array(z);
+
+  // construct positional args
+  PyObject *args = PyTuple_New(3);
+  PyTuple_SetItem(args, 0, xarray);
+  PyTuple_SetItem(args, 1, yarray);
+  PyTuple_SetItem(args, 2, zarray);
+
+  // Build up the kw args.
+  PyObject *kwargs = PyDict_New();
+
+  for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+       it != keywords.end(); ++it) {
+    PyDict_SetItemString(kwargs, it->first.c_str(),
+                         PyString_FromString(it->second.c_str()));
+  }
+
+  PyObject *fig_args = PyTuple_New(1);
+  PyObject* fig = nullptr;
+  PyTuple_SetItem(fig_args, 0, PyLong_FromLong(fig_number));
+  PyObject *fig_exists =
+    PyObject_CallObject(detail::_interpreter::get().s_python_function_fignum_exists, fig_args);
+  if (!PyObject_IsTrue(fig_exists)) {
+    fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+      detail::_interpreter::get().s_python_empty_tuple);
+  } else {
+    fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+      fig_args);
+  }
+  if (!fig) throw std::runtime_error("Call to figure() failed.");
+
+  PyObject *gca_kwargs = PyDict_New();
+  PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
+
+  PyObject *gca = PyObject_GetAttrString(fig, "gca");
+  if (!gca) throw std::runtime_error("No gca");
+  Py_INCREF(gca);
+  PyObject *axis = PyObject_Call(
+      gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
+
+  if (!axis) throw std::runtime_error("No axis");
+  Py_INCREF(axis);
+
+  Py_DECREF(gca);
+  Py_DECREF(gca_kwargs);
+
+  PyObject *plot3 = PyObject_GetAttrString(axis, "plot");
+  if (!plot3) throw std::runtime_error("No 3D line plot");
+  Py_INCREF(plot3);
+  PyObject *res = PyObject_Call(plot3, args, kwargs);
+  if (!res) throw std::runtime_error("Failed 3D line plot");
+  Py_DECREF(plot3);
+
+  Py_DECREF(axis);
+  Py_DECREF(args);
+  Py_DECREF(kwargs);
+  if (res) Py_DECREF(res);
+}
+
+template<typename Numeric>
+bool stem(const std::vector<Numeric> &x, const std::vector<Numeric> &y, const std::map<std::string, std::string>& keywords)
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
 
-		// using numpy arrays
-		PyObject* xarray = get_array(x);
-		PyObject* yarray = get_array(y);
+    // using numpy arrays
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
 
-		// construct positional args
-		PyObject* args = PyTuple_New(2);
-		PyTuple_SetItem(args, 0, xarray);
-		PyTuple_SetItem(args, 1, yarray);
+    // construct positional args
+    PyObject* args = PyTuple_New(2);
+    PyTuple_SetItem(args, 0, xarray);
+    PyTuple_SetItem(args, 1, yarray);
 
-		// construct keyword args
-		PyObject* kwargs = PyDict_New();
-		for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
-		{
-			PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
-		}
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for (std::map<std::string, std::string>::const_iterator it =
+            keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(),
+                PyString_FromString(it->second.c_str()));
+    }
 
-		PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, args, kwargs);
+    PyObject* res = PyObject_Call(
+            detail::_interpreter::get().s_python_function_stem, args, kwargs);
 
-		Py_DECREF(args);
-		Py_DECREF(kwargs);
-		if(res) Py_DECREF(res);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if (res)
+        Py_DECREF(res);
 
-		return res;
-	}
+    return res;
+}
 
-	template< typename Numeric >
-	bool fill_between(const std::vector<Numeric>& x, const std::vector<Numeric>& y1, const std::vector<Numeric>& y2, const std::map<std::string, std::string>& keywords)
-	{
-		assert(x.size() == y1.size());
-		assert(x.size() == y2.size());
+template< typename Numeric >
+bool fill(const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::map<std::string, std::string>& keywords)
+{
+    assert(x.size() == y.size());
 
-		// using numpy arrays
-		PyObject* xarray = get_array(x);
-		PyObject* y1array = get_array(y1);
-		PyObject* y2array = get_array(y2);
+    detail::_interpreter::get();
 
-		// construct positional args
-		PyObject* args = PyTuple_New(3);
-		PyTuple_SetItem(args, 0, xarray);
-		PyTuple_SetItem(args, 1, y1array);
-		PyTuple_SetItem(args, 2, y2array);
+    // using numpy arrays
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
 
-		// construct keyword args
-		PyObject* kwargs = PyDict_New();
-		for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
-		{
-			PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
-		}
+    // construct positional args
+    PyObject* args = PyTuple_New(2);
+    PyTuple_SetItem(args, 0, xarray);
+    PyTuple_SetItem(args, 1, yarray);
 
-		PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_fill_between, args, kwargs);
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
 
-		Py_DECREF(args);
-		Py_DECREF(kwargs);
-		if(res) Py_DECREF(res);
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_fill, args, kwargs);
 
-		return res;
-	}
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
 
-	template< typename Numeric>
-	bool hist(const std::vector<Numeric>& y, long bins=10,std::string color="b", double alpha=1.0)
-	{
+    if (res) Py_DECREF(res);
 
-		PyObject* yarray = get_array(y);
+    return res;
+}
 
-		PyObject* kwargs = PyDict_New();
-		PyDict_SetItemString(kwargs, "bins", PyLong_FromLong(bins));
-		PyDict_SetItemString(kwargs, "color", PyString_FromString(color.c_str()));
-		PyDict_SetItemString(kwargs, "alpha", PyFloat_FromDouble(alpha));
-		
+template< typename Numeric >
+bool fill_between(const std::vector<Numeric>& x, const std::vector<Numeric>& y1, const std::vector<Numeric>& y2, const std::map<std::string, std::string>& keywords)
+{
+    assert(x.size() == y1.size());
+    assert(x.size() == y2.size());
 
-		PyObject* plot_args = PyTuple_New(1);
+    detail::_interpreter::get();
 
-		PyTuple_SetItem(plot_args, 0, yarray);
+    // using numpy arrays
+    PyObject* xarray = detail::get_array(x);
+    PyObject* y1array = detail::get_array(y1);
+    PyObject* y2array = detail::get_array(y2);
 
+    // construct positional args
+    PyObject* args = PyTuple_New(3);
+    PyTuple_SetItem(args, 0, xarray);
+    PyTuple_SetItem(args, 1, y1array);
+    PyTuple_SetItem(args, 2, y2array);
 
-		PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_hist, plot_args, kwargs);
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
 
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_fill_between, args, kwargs);
 
-		Py_DECREF(plot_args);
-		Py_DECREF(kwargs);
-		if(res) Py_DECREF(res);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
 
-		return res;
-	}
+    return res;
+}
 
-	template< typename Numeric>
-	bool named_hist(std::string label,const std::vector<Numeric>& y, long bins=10, std::string color="b", double alpha=1.0)
-	{
-		PyObject* yarray = get_array(y);
+template <typename Numeric>
+bool arrow(Numeric x, Numeric y, Numeric end_x, Numeric end_y, const std::string& fc = "r",
+           const std::string ec = "k", Numeric head_length = 0.25, Numeric head_width = 0.1625) {
+    PyObject* obj_x = PyFloat_FromDouble(x);
+    PyObject* obj_y = PyFloat_FromDouble(y);
+    PyObject* obj_end_x = PyFloat_FromDouble(end_x);
+    PyObject* obj_end_y = PyFloat_FromDouble(end_y);
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "fc", PyString_FromString(fc.c_str()));
+    PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
+    PyDict_SetItemString(kwargs, "head_width", PyFloat_FromDouble(head_width));
+    PyDict_SetItemString(kwargs, "head_length", PyFloat_FromDouble(head_length));
+
+    PyObject* plot_args = PyTuple_New(4);
+    PyTuple_SetItem(plot_args, 0, obj_x);
+    PyTuple_SetItem(plot_args, 1, obj_y);
+    PyTuple_SetItem(plot_args, 2, obj_end_x);
+    PyTuple_SetItem(plot_args, 3, obj_end_y);
+
+    PyObject* res =
+            PyObject_Call(detail::_interpreter::get().s_python_function_arrow, plot_args, kwargs);
+
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if (res)
+        Py_DECREF(res);
+
+    return res;
+}
 
-		PyObject* kwargs = PyDict_New();
-		PyDict_SetItemString(kwargs, "label", PyString_FromString(label.c_str()));
-		PyDict_SetItemString(kwargs, "bins", PyLong_FromLong(bins));
-		PyDict_SetItemString(kwargs, "color", PyString_FromString(color.c_str()));
-		PyDict_SetItemString(kwargs, "alpha", PyFloat_FromDouble(alpha));
+template< typename Numeric>
+bool hist(const std::vector<Numeric>& y, long bins=10,std::string color="b",
+          double alpha=1.0, bool cumulative=false)
+{
+    detail::_interpreter::get();
 
+    PyObject* yarray = detail::get_array(y);
 
-		PyObject* plot_args = PyTuple_New(1);
-		PyTuple_SetItem(plot_args, 0, yarray);
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "bins", PyLong_FromLong(bins));
+    PyDict_SetItemString(kwargs, "color", PyString_FromString(color.c_str()));
+    PyDict_SetItemString(kwargs, "alpha", PyFloat_FromDouble(alpha));
+    PyDict_SetItemString(kwargs, "cumulative", cumulative ? Py_True : Py_False);
 
-		PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_hist, plot_args, kwargs);
+    PyObject* plot_args = PyTuple_New(1);
 
-		Py_DECREF(plot_args);
-		Py_DECREF(kwargs);
-		if(res) Py_DECREF(res);
+    PyTuple_SetItem(plot_args, 0, yarray);
 
-		return res;
-	}
-	
-	template<typename NumericX, typename NumericY>
-	bool plot(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
-	{
-		assert(x.size() == y.size());
 
-		PyObject* xarray = get_array(x);
-		PyObject* yarray = get_array(y);
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_hist, plot_args, kwargs);
 
-		PyObject* pystring = PyString_FromString(s.c_str());
 
-		PyObject* plot_args = PyTuple_New(3);
-		PyTuple_SetItem(plot_args, 0, xarray);
-		PyTuple_SetItem(plot_args, 1, yarray);
-		PyTuple_SetItem(plot_args, 2, pystring);
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
 
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_plot, plot_args);
+    return res;
+}
 
-		Py_DECREF(plot_args);
-		if(res) Py_DECREF(res);
+#ifndef WITHOUT_NUMPY
+namespace detail {
+
+inline void imshow(void *ptr, const NPY_TYPES type, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords, PyObject** out)
+{
+    assert(type == NPY_UINT8 || type == NPY_FLOAT);
+    assert(colors == 1 || colors == 3 || colors == 4);
+
+    detail::_interpreter::get();
+
+    // construct args
+    npy_intp dims[3] = { rows, columns, colors };
+    PyObject *args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyArray_SimpleNewFromData(colors == 1 ? 2 : 3, dims, type, ptr));
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_imshow, args, kwargs);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if (!res)
+        throw std::runtime_error("Call to imshow() failed");
+    if (out)
+        *out = res;
+    else
+        Py_DECREF(res);
+}
 
-		return res;
-	}
+} // namespace detail
 
-	template<typename NumericX, typename NumericY>
-	bool errorbar(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::vector<NumericX> &yerr, const std::string &s = "")
-	{
-		assert(x.size() == y.size());
+inline void imshow(const unsigned char *ptr, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords = {}, PyObject** out = nullptr)
+{
+    detail::imshow((void *) ptr, NPY_UINT8, rows, columns, colors, keywords, out);
+}
 
-		PyObject* xarray = get_array(x);
-		PyObject* yarray = get_array(y);
-		PyObject* yerrarray = get_array(yerr);
+inline void imshow(const float *ptr, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords = {}, PyObject** out = nullptr)
+{
+    detail::imshow((void *) ptr, NPY_FLOAT, rows, columns, colors, keywords, out);
+}
 
-		PyObject *kwargs = PyDict_New();
+#ifdef WITH_OPENCV
+void imshow(const cv::Mat &image, const std::map<std::string, std::string> &keywords = {})
+{
+    // Convert underlying type of matrix, if needed
+    cv::Mat image2;
+    NPY_TYPES npy_type = NPY_UINT8;
+    switch (image.type() & CV_MAT_DEPTH_MASK) {
+    case CV_8U:
+        image2 = image;
+        break;
+    case CV_32F:
+        image2 = image;
+        npy_type = NPY_FLOAT;
+        break;
+    default:
+        image.convertTo(image2, CV_MAKETYPE(CV_8U, image.channels()));
+    }
+
+    // If color image, convert from BGR to RGB
+    switch (image2.channels()) {
+    case 3:
+        cv::cvtColor(image2, image2, CV_BGR2RGB);
+        break;
+    case 4:
+        cv::cvtColor(image2, image2, CV_BGRA2RGBA);
+    }
+
+    detail::imshow(image2.data, npy_type, image2.rows, image2.cols, image2.channels(), keywords);
+}
+#endif // WITH_OPENCV
+#endif // WITHOUT_NUMPY
 
-		PyDict_SetItemString(kwargs, "yerr", yerrarray);
+template<typename NumericX, typename NumericY>
+bool scatter(const std::vector<NumericX>& x,
+             const std::vector<NumericY>& y,
+             const double s=1.0, // The marker size in points**2
+             const std::map<std::string, std::string> & keywords = {})
+{
+    detail::_interpreter::get();
 
-		PyObject *pystring = PyString_FromString(s.c_str());
+    assert(x.size() == y.size());
 
-		PyObject *plot_args = PyTuple_New(2);
-		PyTuple_SetItem(plot_args, 0, xarray);
-		PyTuple_SetItem(plot_args, 1, yarray);
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
 
-		PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_errorbar, plot_args, kwargs);
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "s", PyLong_FromLong(s));
+    for (const auto& it : keywords)
+    {
+        PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+    }
 
-		Py_DECREF(kwargs);
-		Py_DECREF(plot_args);
+    PyObject* plot_args = PyTuple_New(2);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
 
-		if (res)
-			Py_DECREF(res);
-		else
-			throw std::runtime_error("Call to errorbar() failed.");
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_scatter, plot_args, kwargs);
 
-		return res;
-	}
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
 
-	template<typename Numeric>
-	bool named_plot(const std::string& name, const std::vector<Numeric>& y, const std::string& format = "")
-	{
-		PyObject* kwargs = PyDict_New();
-		PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+    return res;
+}
 
-		PyObject* yarray = get_array(y);
+template<typename NumericX, typename NumericY, typename NumericColors>
+    bool scatter_colored(const std::vector<NumericX>& x,
+                 const std::vector<NumericY>& y,
+                 const std::vector<NumericColors>& colors,
+                 const double s=1.0, // The marker size in points**2
+                 const std::map<std::string, std::string> & keywords = {})
+    {
+        detail::_interpreter::get();
 
-		PyObject* pystring = PyString_FromString(format.c_str());
+        assert(x.size() == y.size());
 
-		PyObject* plot_args = PyTuple_New(2);
+        PyObject* xarray = detail::get_array(x);
+        PyObject* yarray = detail::get_array(y);
+        PyObject* colors_array = detail::get_array(colors);
 
-		PyTuple_SetItem(plot_args, 0, yarray);
-		PyTuple_SetItem(plot_args, 1, pystring);
+        PyObject* kwargs = PyDict_New();
+        PyDict_SetItemString(kwargs, "s", PyLong_FromLong(s));
+        PyDict_SetItemString(kwargs, "c", colors_array);
 
-		PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);
+        for (const auto& it : keywords)
+        {
+            PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+        }
 
-		Py_DECREF(kwargs);
-		Py_DECREF(plot_args);
-		if(res) Py_DECREF(res);
+        PyObject* plot_args = PyTuple_New(2);
+        PyTuple_SetItem(plot_args, 0, xarray);
+        PyTuple_SetItem(plot_args, 1, yarray);
 
-		return res;
-	}
+        PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_scatter, plot_args, kwargs);
 
-	template<typename Numeric>
-	bool named_plot(const std::string& name, const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::string& format = "")
-	{
-		PyObject* kwargs = PyDict_New();
-		PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+        Py_DECREF(plot_args);
+        Py_DECREF(kwargs);
+        if(res) Py_DECREF(res);
 
-		PyObject* xarray = get_array(x);
-		PyObject* yarray = get_array(y);
+        return res;
+    }
+    
 
-		PyObject* pystring = PyString_FromString(format.c_str());
+template<typename NumericX, typename NumericY, typename NumericZ>
+bool scatter(const std::vector<NumericX>& x,
+             const std::vector<NumericY>& y,
+             const std::vector<NumericZ>& z,
+             const double s=1.0, // The marker size in points**2
+             const std::map<std::string, std::string> & keywords = {},
+             const long fig_number=0) {
+  detail::_interpreter::get();
+
+  // Same as with plot_surface: We lazily load the modules here the first time 
+  // this function is called because I'm not sure that we can assume "matplotlib 
+  // installed" implies "mpl_toolkits installed" on all platforms, and we don't 
+  // want to require it for people who don't need 3d plots.
+  static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+  if (!mpl_toolkitsmod) {
+    detail::_interpreter::get();
+
+    PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+    PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+    if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+    mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+    Py_DECREF(mpl_toolkits);
+    if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+    axis3dmod = PyImport_Import(axis3d);
+    Py_DECREF(axis3d);
+    if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+  }
+
+  assert(x.size() == y.size());
+  assert(y.size() == z.size());
+
+  PyObject *xarray = detail::get_array(x);
+  PyObject *yarray = detail::get_array(y);
+  PyObject *zarray = detail::get_array(z);
+
+  // construct positional args
+  PyObject *args = PyTuple_New(3);
+  PyTuple_SetItem(args, 0, xarray);
+  PyTuple_SetItem(args, 1, yarray);
+  PyTuple_SetItem(args, 2, zarray);
+
+  // Build up the kw args.
+  PyObject *kwargs = PyDict_New();
+
+  for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+       it != keywords.end(); ++it) {
+    PyDict_SetItemString(kwargs, it->first.c_str(),
+                         PyString_FromString(it->second.c_str()));
+  }
+  PyObject *fig_args = PyTuple_New(1);
+  PyObject* fig = nullptr;
+  PyTuple_SetItem(fig_args, 0, PyLong_FromLong(fig_number));
+  PyObject *fig_exists =
+    PyObject_CallObject(detail::_interpreter::get().s_python_function_fignum_exists, fig_args);
+  if (!PyObject_IsTrue(fig_exists)) {
+    fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+      detail::_interpreter::get().s_python_empty_tuple);
+  } else {
+    fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+      fig_args);
+  }
+  Py_DECREF(fig_exists);
+  if (!fig) throw std::runtime_error("Call to figure() failed.");
+
+  PyObject *gca_kwargs = PyDict_New();
+  PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
+
+  PyObject *gca = PyObject_GetAttrString(fig, "gca");
+  if (!gca) throw std::runtime_error("No gca");
+  Py_INCREF(gca);
+  PyObject *axis = PyObject_Call(
+      gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
+
+  if (!axis) throw std::runtime_error("No axis");
+  Py_INCREF(axis);
+
+  Py_DECREF(gca);
+  Py_DECREF(gca_kwargs);
+
+  PyObject *plot3 = PyObject_GetAttrString(axis, "scatter");
+  if (!plot3) throw std::runtime_error("No 3D line plot");
+  Py_INCREF(plot3);
+  PyObject *res = PyObject_Call(plot3, args, kwargs);
+  if (!res) throw std::runtime_error("Failed 3D line plot");
+  Py_DECREF(plot3);
+
+  Py_DECREF(axis);
+  Py_DECREF(args);
+  Py_DECREF(kwargs);
+  Py_DECREF(fig);
+  if (res) Py_DECREF(res);
+  return res;
 
-		PyObject* plot_args = PyTuple_New(3);
-		PyTuple_SetItem(plot_args, 0, xarray);
-		PyTuple_SetItem(plot_args, 1, yarray);
-		PyTuple_SetItem(plot_args, 2, pystring);
+}
 
-		PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);
+template<typename Numeric>
+bool boxplot(const std::vector<std::vector<Numeric>>& data,
+             const std::vector<std::string>& labels = {},
+             const std::map<std::string, std::string> & keywords = {})
+{
+    detail::_interpreter::get();
 
-		Py_DECREF(kwargs);
-		Py_DECREF(plot_args);
-		if(res) Py_DECREF(res);
+    PyObject* listlist = detail::get_listlist(data);
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, listlist);
 
-		return res;
-	}
+    PyObject* kwargs = PyDict_New();
 
-	template<typename Numeric>
-	bool plot(const std::vector<Numeric>& y, const std::string& format = "")
-	{
-		std::vector<Numeric> x(y.size());
-		for(size_t i=0; i<x.size(); ++i) x.at(i) = i;
-		return plot(x,y,format);
-	}
+    // kwargs needs the labels, if there are (the correct number of) labels
+    if (!labels.empty() && labels.size() == data.size()) {
+        PyDict_SetItemString(kwargs, "labels", detail::get_array(labels));
+    }
 
-	inline void figure()
-	{
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure, detail::_interpreter::get().s_python_empty_tuple);
-		if(!res) throw std::runtime_error("Call to figure() failed.");
+    // take care of the remaining keywords
+    for (const auto& it : keywords)
+    {
+        PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+    }
 
-		Py_DECREF(res);
-	}
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_boxplot, args, kwargs);
 
-	inline void legend()
-	{
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_legend, detail::_interpreter::get().s_python_empty_tuple);
-		if(!res) throw std::runtime_error("Call to legend() failed.");
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
 
-		Py_DECREF(res);
-	}
+    if(res) Py_DECREF(res);
 
-	template<typename Numeric>
-	void ylim(Numeric left, Numeric right)
-	{
-		PyObject* list = PyList_New(2);
-		PyList_SetItem(list, 0, PyFloat_FromDouble(left));
-		PyList_SetItem(list, 1, PyFloat_FromDouble(right));
+    return res;
+}
 
-		PyObject* args = PyTuple_New(1);
-		PyTuple_SetItem(args, 0, list);
+template<typename Numeric>
+bool boxplot(const std::vector<Numeric>& data,
+             const std::map<std::string, std::string> & keywords = {})
+{
+    detail::_interpreter::get();
 
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);
-		if(!res) throw std::runtime_error("Call to ylim() failed.");
+    PyObject* vector = detail::get_array(data);
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, vector);
 
-		Py_DECREF(args);
-		Py_DECREF(res);
-	}
+    PyObject* kwargs = PyDict_New();
+    for (const auto& it : keywords)
+    {
+        PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+    }
 
-	template<typename Numeric>
-	void xlim(Numeric left, Numeric right)
-	{
-		PyObject* list = PyList_New(2);
-		PyList_SetItem(list, 0, PyFloat_FromDouble(left));
-		PyList_SetItem(list, 1, PyFloat_FromDouble(right));
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_boxplot, args, kwargs);
 
-		PyObject* args = PyTuple_New(1);
-		PyTuple_SetItem(args, 0, list);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
 
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);
-		if(!res) throw std::runtime_error("Call to xlim() failed.");
+    if(res) Py_DECREF(res);
 
-		Py_DECREF(args);
-		Py_DECREF(res);
-	}
-  
-  
-	inline double* xlim()
-	{
-		PyObject* args = PyTuple_New(0);
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);
-		PyObject* left = PyTuple_GetItem(res,0);
-		PyObject* right = PyTuple_GetItem(res,1);
-
-		double* arr = new double[2];
-		arr[0] = PyFloat_AsDouble(left);
-		arr[1] = PyFloat_AsDouble(right);
-    
-		if(!res) throw std::runtime_error("Call to xlim() failed.");
+    return res;
+}
 
-		Py_DECREF(res);
-		return arr;
-	}
-  
+template <typename Numeric>
+bool bar(const std::vector<Numeric> &               x,
+         const std::vector<Numeric> &               y,
+         std::string                                ec       = "black",
+         std::string                                ls       = "-",
+         double                                     lw       = 1.0,
+         const std::map<std::string, std::string> & keywords = {})
+{
+  detail::_interpreter::get();
+
+  PyObject * xarray = detail::get_array(x);
+  PyObject * yarray = detail::get_array(y);
+
+  PyObject * kwargs = PyDict_New();
+
+  PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
+  PyDict_SetItemString(kwargs, "ls", PyString_FromString(ls.c_str()));
+  PyDict_SetItemString(kwargs, "lw", PyFloat_FromDouble(lw));
+
+  for (std::map<std::string, std::string>::const_iterator it =
+         keywords.begin();
+       it != keywords.end();
+       ++it) {
+    PyDict_SetItemString(
+      kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+  }
+
+  PyObject * plot_args = PyTuple_New(2);
+  PyTuple_SetItem(plot_args, 0, xarray);
+  PyTuple_SetItem(plot_args, 1, yarray);
+
+  PyObject * res = PyObject_Call(
+    detail::_interpreter::get().s_python_function_bar, plot_args, kwargs);
+
+  Py_DECREF(plot_args);
+  Py_DECREF(kwargs);
+  if (res) Py_DECREF(res);
+
+  return res;
+}
+
+template <typename Numeric>
+bool bar(const std::vector<Numeric> &               y,
+         std::string                                ec       = "black",
+         std::string                                ls       = "-",
+         double                                     lw       = 1.0,
+         const std::map<std::string, std::string> & keywords = {})
+{
+  using T = typename std::remove_reference<decltype(y)>::type::value_type;
+
+  detail::_interpreter::get();
+
+  std::vector<T> x;
+  for (std::size_t i = 0; i < y.size(); i++) { x.push_back(i); }
+
+  return bar(x, y, ec, ls, lw, keywords);
+}
+
+
+template<typename Numeric>
+bool barh(const std::vector<Numeric> &x, const std::vector<Numeric> &y, std::string ec = "black", std::string ls = "-", double lw = 1.0, const std::map<std::string, std::string> &keywords = { }) {
+    PyObject *xarray = detail::get_array(x);
+    PyObject *yarray = detail::get_array(y);
+
+    PyObject *kwargs = PyDict_New();
+
+    PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
+    PyDict_SetItemString(kwargs, "ls", PyString_FromString(ls.c_str()));
+    PyDict_SetItemString(kwargs, "lw", PyFloat_FromDouble(lw));
+
+    for (std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject *plot_args = PyTuple_New(2);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+
+    PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_barh, plot_args, kwargs);
+
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+
+inline bool subplots_adjust(const std::map<std::string, double>& keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    for (std::map<std::string, double>::const_iterator it =
+            keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(),
+                             PyFloat_FromDouble(it->second));
+    }
+
+
+    PyObject* plot_args = PyTuple_New(0);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_subplots_adjust, plot_args, kwargs);
+
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template< typename Numeric>
+bool named_hist(std::string label,const std::vector<Numeric>& y, long bins=10, std::string color="b", double alpha=1.0)
+{
+    detail::_interpreter::get();
+
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(label.c_str()));
+    PyDict_SetItemString(kwargs, "bins", PyLong_FromLong(bins));
+    PyDict_SetItemString(kwargs, "color", PyString_FromString(color.c_str()));
+    PyDict_SetItemString(kwargs, "alpha", PyFloat_FromDouble(alpha));
+
+
+    PyObject* plot_args = PyTuple_New(1);
+    PyTuple_SetItem(plot_args, 0, yarray);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_hist, plot_args, kwargs);
+
+    Py_DECREF(plot_args);
+    Py_DECREF(kwargs);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool plot(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(s.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_plot, plot_args);
+
+    Py_DECREF(plot_args);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template <typename NumericX, typename NumericY, typename NumericZ>
+bool contour(const std::vector<NumericX>& x, const std::vector<NumericY>& y,
+             const std::vector<NumericZ>& z,
+             const std::map<std::string, std::string>& keywords = {}) {
+    assert(x.size() == y.size() && x.size() == z.size());
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+    PyObject* zarray = detail::get_array(z);
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, zarray);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+         it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res =
+            PyObject_Call(detail::_interpreter::get().s_python_function_contour, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res)
+        Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY, typename NumericU, typename NumericW>
+bool quiver(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::vector<NumericU>& u, const std::vector<NumericW>& w, const std::map<std::string, std::string>& keywords = {})
+{
+    assert(x.size() == y.size() && x.size() == u.size() && u.size() == w.size());
+
+    detail::_interpreter::get();
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+    PyObject* uarray = detail::get_array(u);
+    PyObject* warray = detail::get_array(w);
+
+    PyObject* plot_args = PyTuple_New(4);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, uarray);
+    PyTuple_SetItem(plot_args, 3, warray);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(
+            detail::_interpreter::get().s_python_function_quiver, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res)
+        Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY, typename NumericZ, typename NumericU, typename NumericW, typename NumericV>
+bool quiver(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::vector<NumericZ>& z, const std::vector<NumericU>& u, const std::vector<NumericW>& w, const std::vector<NumericV>& v, const std::map<std::string, std::string>& keywords = {})
+{
+  //set up 3d axes stuff
+  static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+  if (!mpl_toolkitsmod) {
+    detail::_interpreter::get();
+
+    PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+    PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+    if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+    mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+    Py_DECREF(mpl_toolkits);
+    if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+    axis3dmod = PyImport_Import(axis3d);
+    Py_DECREF(axis3d);
+    if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+  }
   
-	inline double* ylim()
-	{
-		PyObject* args = PyTuple_New(0);
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);
-		PyObject* left = PyTuple_GetItem(res,0);
-		PyObject* right = PyTuple_GetItem(res,1);
-
-		double* arr = new double[2];
-		arr[0] = PyFloat_AsDouble(left);
-		arr[1] = PyFloat_AsDouble(right);
+  //assert sizes match up
+  assert(x.size() == y.size() && x.size() == u.size() && u.size() == w.size() && x.size() == z.size() && x.size() == v.size() && u.size() == v.size());
+
+  //set up parameters
+  detail::_interpreter::get();
+
+  PyObject* xarray = detail::get_array(x);
+  PyObject* yarray = detail::get_array(y);
+  PyObject* zarray = detail::get_array(z);
+  PyObject* uarray = detail::get_array(u);
+  PyObject* warray = detail::get_array(w);
+  PyObject* varray = detail::get_array(v);
+
+  PyObject* plot_args = PyTuple_New(6);
+  PyTuple_SetItem(plot_args, 0, xarray);
+  PyTuple_SetItem(plot_args, 1, yarray);
+  PyTuple_SetItem(plot_args, 2, zarray);
+  PyTuple_SetItem(plot_args, 3, uarray);
+  PyTuple_SetItem(plot_args, 4, warray);
+  PyTuple_SetItem(plot_args, 5, varray);
+
+  // construct keyword args
+  PyObject* kwargs = PyDict_New();
+  for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+  {
+      PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+  }
     
-		if(!res) throw std::runtime_error("Call to ylim() failed."); 
+  //get figure gca to enable 3d projection
+  PyObject *fig =
+      PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+                          detail::_interpreter::get().s_python_empty_tuple);
+  if (!fig) throw std::runtime_error("Call to figure() failed.");
+
+  PyObject *gca_kwargs = PyDict_New();
+  PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
+
+  PyObject *gca = PyObject_GetAttrString(fig, "gca");
+  if (!gca) throw std::runtime_error("No gca");
+  Py_INCREF(gca);
+  PyObject *axis = PyObject_Call(
+      gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
+
+  if (!axis) throw std::runtime_error("No axis");
+  Py_INCREF(axis);
+  Py_DECREF(gca);
+  Py_DECREF(gca_kwargs);
+  
+  //plot our boys bravely, plot them strongly, plot them with a wink and clap
+  PyObject *plot3 = PyObject_GetAttrString(axis, "quiver");
+  if (!plot3) throw std::runtime_error("No 3D line plot");
+  Py_INCREF(plot3);
+  PyObject* res = PyObject_Call(
+          plot3, plot_args, kwargs);
+  if (!res) throw std::runtime_error("Failed 3D plot");
+  Py_DECREF(plot3);
+  Py_DECREF(axis);
+  Py_DECREF(kwargs);
+  Py_DECREF(plot_args);
+  if (res)
+      Py_DECREF(res);
+
+  return res;
+}
 
-		Py_DECREF(res);
-		return arr;
-	}
+template<typename NumericX, typename NumericY>
+bool stem(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+    assert(x.size() == y.size());
 
-	inline void subplot(long nrows, long ncols, long plot_number)
-	{
-		// construct positional args
-		PyObject* args = PyTuple_New(3);
-		PyTuple_SetItem(args, 0, PyFloat_FromDouble(nrows));
-		PyTuple_SetItem(args, 1, PyFloat_FromDouble(ncols));
-		PyTuple_SetItem(args, 2, PyFloat_FromDouble(plot_number));
+    detail::_interpreter::get();
 
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_subplot, args);
-		if(!res) throw std::runtime_error("Call to subplot() failed.");
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
 
-		Py_DECREF(args);
-		Py_DECREF(res);
-	}
+    PyObject* pystring = PyString_FromString(s.c_str());
 
-	inline void title(const std::string &titlestr)
-	{
-		PyObject* pytitlestr = PyString_FromString(titlestr.c_str());
-		PyObject* args = PyTuple_New(1);
-		PyTuple_SetItem(args, 0, pytitlestr);
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
 
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_title, args);
-		if(!res) throw std::runtime_error("Call to title() failed.");
+    PyObject* res = PyObject_CallObject(
+            detail::_interpreter::get().s_python_function_stem, plot_args);
 
-		// if PyDeCRFF, the function doesn't work on Mac OS
-	}
+    Py_DECREF(plot_args);
+    if (res)
+        Py_DECREF(res);
 
-	inline void axis(const std::string &axisstr)
-	{
-		PyObject* str = PyString_FromString(axisstr.c_str());
-		PyObject* args = PyTuple_New(1);
-		PyTuple_SetItem(args, 0, str);
+    return res;
+}
 
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_axis, args);
-		if(!res) throw std::runtime_error("Call to title() failed.");
+template<typename NumericX, typename NumericY>
+bool semilogx(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+    assert(x.size() == y.size());
 
-		// if PyDeCRFF, the function doesn't work on Mac OS
-	}
+    detail::_interpreter::get();
 
-	inline void xlabel(const std::string &str)
-	{
-		PyObject* pystr = PyString_FromString(str.c_str());
-		PyObject* args = PyTuple_New(1);
-		PyTuple_SetItem(args, 0, pystr);
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
 
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlabel, args);
-		if(!res) throw std::runtime_error("Call to xlabel() failed.");
+    PyObject* pystring = PyString_FromString(s.c_str());
 
-		// if PyDeCRFF, the function doesn't work on Mac OS
-	}
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
 
-	inline void ylabel(const std::string &str)
-	{
-		PyObject* pystr = PyString_FromString(str.c_str());
-		PyObject* args = PyTuple_New(1);
-		PyTuple_SetItem(args, 0, pystr);
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_semilogx, plot_args);
 
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylabel, args);
-		if(!res) throw std::runtime_error("Call to ylabel() failed.");
+    Py_DECREF(plot_args);
+    if(res) Py_DECREF(res);
 
-		// if PyDeCRFF, the function doesn't work on Mac OS
-	}
+    return res;
+}
 
-	inline void grid(bool flag)
-	{
-		PyObject* pyflag = flag ? Py_True : Py_False;
+template<typename NumericX, typename NumericY>
+bool semilogy(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+    assert(x.size() == y.size());
 
-		PyObject* args = PyTuple_New(1);
-		PyTuple_SetItem(args, 0, pyflag);
+    detail::_interpreter::get();
 
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_grid, args);
-		if(!res) throw std::runtime_error("Call to grid() failed.");
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
 
-		// if PyDeCRFF, the function doesn't work on Mac OS
-	}
+    PyObject* pystring = PyString_FromString(s.c_str());
 
-	inline void show()
-	{
-		PyObject* res = PyObject_CallObject(
-			detail::_interpreter::get().s_python_function_show,
-			detail::_interpreter::get().s_python_empty_tuple);
-
-		if (!res) throw std::runtime_error("Call to show() failed.");
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
 
-		Py_DECREF(res);
-	}
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_semilogy, plot_args);
 
-	inline void save(const std::string& filename)
-	{
-		PyObject* pyfilename = PyString_FromString(filename.c_str());
-
-		PyObject* args = PyTuple_New(1);
-		PyTuple_SetItem(args, 0, pyfilename);
-
-		PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_save, args);
-		if (!res) throw std::runtime_error("Call to save() failed.");
-
-		Py_DECREF(args);
-		Py_DECREF(res);
-	}
-
-	inline void clf() {
-		PyObject *res = PyObject_CallObject(
-			detail::_interpreter::get().s_python_function_clf,
-			detail::_interpreter::get().s_python_empty_tuple);
+    Py_DECREF(plot_args);
+    if(res) Py_DECREF(res);
 
-		if (!res) throw std::runtime_error("Call to clf() failed.");
+    return res;
+}
 
-		Py_DECREF(res);
-	}
+template<typename NumericX, typename NumericY>
+bool loglog(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+    assert(x.size() == y.size());
 
-	// Actually, is there any reason not to call this automatically for every plot?
-	inline void tight_layout() {
-		PyObject *res = PyObject_CallObject(
-			detail::_interpreter::get().s_python_function_tight_layout,
-			detail::_interpreter::get().s_python_empty_tuple);
+    detail::_interpreter::get();
 
-		if (!res) throw std::runtime_error("Call to tight_layout() failed.");
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
 
-		Py_DECREF(res);
-	}
-
-#if __cplusplus > 199711L || _MSC_VER > 1800
-	// C++11-exclusive content starts here (variadic plot() and initializer list support)
-
-	namespace detail {
-		template<typename T>
-		using is_function = typename std::is_function<std::remove_pointer<std::remove_reference<T>>>::type;
-
-		template<bool obj, typename T>
-		struct is_callable_impl;
-
-		template<typename T>
-		struct is_callable_impl<false, T>
-		{
-			typedef is_function<T> type;
-		}; // a non-object is callable iff it is a function
-
-		template<typename T>
-		struct is_callable_impl<true, T>
-		{
-			struct Fallback { void operator()(); };
-			struct Derived : T, Fallback { };
-
-			template<typename U, U> struct Check;
-
-			template<typename U>
-			static std::true_type test( ... ); // use a variadic function to make sure (1) it accepts everything and (2) its always the worst match
-
-			template<typename U>
-			static std::false_type test( Check<void(Fallback::*)(), &U::operator()>* );
-
-		public:
-			typedef decltype(test<Derived>(nullptr)) type;
-			typedef decltype(&Fallback::operator()) dtype;
-			static constexpr bool value = type::value;
-		}; // an object is callable iff it defines operator()
-
-		template<typename T>
-		struct is_callable
-		{
-			// dispatch to is_callable_impl<true, T> or is_callable_impl<false, T> depending on whether T is of class type or not
-			typedef typename is_callable_impl<std::is_class<T>::value, T>::type type;
-		};
-
-		template<typename IsYDataCallable>
-		struct plot_impl { };
-
-		template<>
-		struct plot_impl<std::false_type>
-		{
-			template<typename IterableX, typename IterableY>
-			bool operator()(const IterableX& x, const IterableY& y, const std::string& format)
-			{
-				// 2-phase lookup for distance, begin, end
-				using std::distance;
-				using std::begin;
-				using std::end;
-
-				auto xs = distance(begin(x), end(x));
-				auto ys = distance(begin(y), end(y));
-				assert(xs == ys && "x and y data must have the same number of elements!");
-
-				PyObject* xlist = PyList_New(xs);
-				PyObject* ylist = PyList_New(ys);
-				PyObject* pystring = PyString_FromString(format.c_str());
-
-				auto itx = begin(x), ity = begin(y);
-				for(size_t i = 0; i < xs; ++i) {
-					PyList_SetItem(xlist, i, PyFloat_FromDouble(*itx++));
-					PyList_SetItem(ylist, i, PyFloat_FromDouble(*ity++));
-				}
-
-				PyObject* plot_args = PyTuple_New(3);
-				PyTuple_SetItem(plot_args, 0, xlist);
-				PyTuple_SetItem(plot_args, 1, ylist);
-				PyTuple_SetItem(plot_args, 2, pystring);
-
-				PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_plot, plot_args);
-
-				Py_DECREF(plot_args);
-				if(res) Py_DECREF(res);
-
-				return res;
-			}
-		};
-
-		template<>
-		struct plot_impl<std::true_type>
-		{
-			template<typename Iterable, typename Callable>
-			bool operator()(const Iterable& ticks, const Callable& f, const std::string& format)
-			{
-				//std::cout << "Callable impl called" << std::endl;
-
-				if(begin(ticks) == end(ticks)) return true;
-
-				// We could use additional meta-programming to deduce the correct element type of y,
-				// but all values have to be convertible to double anyways
-				std::vector<double> y;
-				for(auto x : ticks) y.push_back(f(x));
-				return plot_impl<std::false_type>()(ticks,y,format);
-			}
-		};
-	}
-
-	// recursion stop for the above
-	template<typename... Args>
-	bool plot() { return true; }
-
-	template<typename A, typename B, typename... Args>
-	bool plot(const A& a, const B& b, const std::string& format, Args... args)
-	{
-		return detail::plot_impl<typename detail::is_callable<B>::type>()(a,b,format) && plot(args...);
-	}
-
-	/*
-	 * This group of plot() functions is needed to support initializer lists, i.e. calling
-	 *    plot( {1,2,3,4} )
-	 */
-	bool plot(const std::vector<double>& x, const std::vector<double>& y, const std::string& format = "") {
-		return plot<double,double>(x,y,format);
-	}
-
-	bool plot(const std::vector<double>& y, const std::string& format = "") {
-		return plot<double>(y,format);
-	}
-
-	bool plot(const std::vector<double>& x, const std::vector<double>& y, const std::map<std::string, std::string>& keywords) {
-		return plot<double>(x,y,keywords);
-	}
-
-	bool named_plot(const std::string& name, const std::vector<double>& x, const std::vector<double>& y, const std::string& format = "") {
-		return named_plot<double>(name,x,y,format);
-	}
+    PyObject* pystring = PyString_FromString(s.c_str());
 
-#endif
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_loglog, plot_args);
+
+    Py_DECREF(plot_args);
+    if(res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool errorbar(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::vector<NumericX> &yerr, const std::map<std::string, std::string> &keywords = {})
+{
+    assert(x.size() == y.size());
+
+    detail::_interpreter::get();
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+    PyObject* yerrarray = detail::get_array(yerr);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyDict_SetItemString(kwargs, "yerr", yerrarray);
+
+    PyObject *plot_args = PyTuple_New(2);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
 
+    PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_errorbar, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+
+    if (res)
+        Py_DECREF(res);
+    else
+        throw std::runtime_error("Call to errorbar() failed.");
+
+    return res;
+}
+
+template<typename Numeric>
+bool named_plot(const std::string& name, const std::vector<Numeric>& y, const std::string& format = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(format.c_str());
+
+    PyObject* plot_args = PyTuple_New(2);
+
+    PyTuple_SetItem(plot_args, 0, yarray);
+    PyTuple_SetItem(plot_args, 1, pystring);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res) Py_DECREF(res);
+
+    return res;
 }
+
+template<typename NumericX, typename NumericY>
+bool named_plot(const std::string& name, const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& format = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(format.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool named_semilogx(const std::string& name, const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& format = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(format.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_semilogx, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool named_semilogy(const std::string& name, const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& format = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(format.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_semilogy, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool named_loglog(const std::string& name, const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& format = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+    PyObject* xarray = detail::get_array(x);
+    PyObject* yarray = detail::get_array(y);
+
+    PyObject* pystring = PyString_FromString(format.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, xarray);
+    PyTuple_SetItem(plot_args, 1, yarray);
+    PyTuple_SetItem(plot_args, 2, pystring);
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_loglog, plot_args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(plot_args);
+    if (res) Py_DECREF(res);
+
+    return res;
+}
+
+template<typename Numeric>
+bool plot(const std::vector<Numeric>& y, const std::string& format = "")
+{
+    std::vector<Numeric> x(y.size());
+    for(size_t i=0; i<x.size(); ++i) x.at(i) = i;
+    return plot(x,y,format);
+}
+
+template<typename Numeric>
+bool plot(const std::vector<Numeric>& y, const std::map<std::string, std::string>& keywords)
+{
+    std::vector<Numeric> x(y.size());
+    for(size_t i=0; i<x.size(); ++i) x.at(i) = i;
+    return plot(x,y,keywords);
+}
+
+template<typename Numeric>
+bool stem(const std::vector<Numeric>& y, const std::string& format = "")
+{
+    std::vector<Numeric> x(y.size());
+    for (size_t i = 0; i < x.size(); ++i) x.at(i) = i;
+    return stem(x, y, format);
+}
+
+template<typename Numeric>
+void text(Numeric x, Numeric y, const std::string& s = "")
+{
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(3);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(x));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(y));
+    PyTuple_SetItem(args, 2, PyString_FromString(s.c_str()));
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_text, args);
+    if(!res) throw std::runtime_error("Call to text() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void colorbar(PyObject* mappable = NULL, const std::map<std::string, float>& keywords = {})
+{
+    if (mappable == NULL)
+        throw std::runtime_error("Must call colorbar with PyObject* returned from an image, contour, surface, etc.");
+
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, mappable);
+
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, float>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyFloat_FromDouble(it->second));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_colorbar, args, kwargs);
+    if(!res) throw std::runtime_error("Call to colorbar() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+
+inline long figure(long number = -1)
+{
+    detail::_interpreter::get();
+
+    PyObject *res;
+    if (number == -1)
+        res = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure, detail::_interpreter::get().s_python_empty_tuple);
+    else {
+        assert(number > 0);
+
+        // Make sure interpreter is initialised
+        detail::_interpreter::get();
+
+        PyObject *args = PyTuple_New(1);
+        PyTuple_SetItem(args, 0, PyLong_FromLong(number));
+        res = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure, args);
+        Py_DECREF(args);
+    }
+
+    if(!res) throw std::runtime_error("Call to figure() failed.");
+
+    PyObject* num = PyObject_GetAttrString(res, "number");
+    if (!num) throw std::runtime_error("Could not get number attribute of figure object");
+    const long figureNumber = PyLong_AsLong(num);
+
+    Py_DECREF(num);
+    Py_DECREF(res);
+
+    return figureNumber;
+}
+
+inline bool fignum_exists(long number)
+{
+    detail::_interpreter::get();
+
+    PyObject *args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyLong_FromLong(number));
+    PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_fignum_exists, args);
+    if(!res) throw std::runtime_error("Call to fignum_exists() failed.");
+
+    bool ret = PyObject_IsTrue(res);
+    Py_DECREF(res);
+    Py_DECREF(args);
+
+    return ret;
+}
+
+inline void figure_size(size_t w, size_t h)
+{
+    detail::_interpreter::get();
+
+    const size_t dpi = 100;
+    PyObject* size = PyTuple_New(2);
+    PyTuple_SetItem(size, 0, PyFloat_FromDouble((double)w / dpi));
+    PyTuple_SetItem(size, 1, PyFloat_FromDouble((double)h / dpi));
+
+    PyObject* kwargs = PyDict_New();
+    PyDict_SetItemString(kwargs, "figsize", size);
+    PyDict_SetItemString(kwargs, "dpi", PyLong_FromSize_t(dpi));
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_figure,
+            detail::_interpreter::get().s_python_empty_tuple, kwargs);
+
+    Py_DECREF(kwargs);
+
+    if(!res) throw std::runtime_error("Call to figure_size() failed.");
+    Py_DECREF(res);
+}
+
+inline void legend()
+{
+    detail::_interpreter::get();
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_legend, detail::_interpreter::get().s_python_empty_tuple);
+    if(!res) throw std::runtime_error("Call to legend() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void legend(const std::map<std::string, std::string>& keywords)
+{
+  detail::_interpreter::get();
+
+  // construct keyword args
+  PyObject* kwargs = PyDict_New();
+  for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+  {
+    PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+  }
+
+  PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_legend, detail::_interpreter::get().s_python_empty_tuple, kwargs);
+  if(!res) throw std::runtime_error("Call to legend() failed.");
+
+  Py_DECREF(kwargs);
+  Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void set_aspect(Numeric ratio)
+{
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(ratio));
+    PyObject* kwargs = PyDict_New();
+
+    PyObject *ax =
+    PyObject_CallObject(detail::_interpreter::get().s_python_function_gca,
+      detail::_interpreter::get().s_python_empty_tuple);
+    if (!ax) throw std::runtime_error("Call to gca() failed.");
+    Py_INCREF(ax);
+
+    PyObject *set_aspect = PyObject_GetAttrString(ax, "set_aspect");
+    if (!set_aspect) throw std::runtime_error("Attribute set_aspect not found.");
+    Py_INCREF(set_aspect);
+
+    PyObject *res = PyObject_Call(set_aspect, args, kwargs);
+    if (!res) throw std::runtime_error("Call to set_aspect() failed.");
+    Py_DECREF(set_aspect);
+
+    Py_DECREF(ax);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+}
+
+inline void set_aspect_equal()
+{
+    // expect ratio == "equal". Leaving error handling to matplotlib.
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyString_FromString("equal"));
+    PyObject* kwargs = PyDict_New();
+
+    PyObject *ax =
+    PyObject_CallObject(detail::_interpreter::get().s_python_function_gca,
+      detail::_interpreter::get().s_python_empty_tuple);
+    if (!ax) throw std::runtime_error("Call to gca() failed.");
+    Py_INCREF(ax);
+
+    PyObject *set_aspect = PyObject_GetAttrString(ax, "set_aspect");
+    if (!set_aspect) throw std::runtime_error("Attribute set_aspect not found.");
+    Py_INCREF(set_aspect);
+
+    PyObject *res = PyObject_Call(set_aspect, args, kwargs);
+    if (!res) throw std::runtime_error("Call to set_aspect() failed.");
+    Py_DECREF(set_aspect);
+
+    Py_DECREF(ax);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+}
+
+template<typename Numeric>
+void ylim(Numeric left, Numeric right)
+{
+    detail::_interpreter::get();
+
+    PyObject* list = PyList_New(2);
+    PyList_SetItem(list, 0, PyFloat_FromDouble(left));
+    PyList_SetItem(list, 1, PyFloat_FromDouble(right));
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, list);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);
+    if(!res) throw std::runtime_error("Call to ylim() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+template<typename Numeric>
+void xlim(Numeric left, Numeric right)
+{
+    detail::_interpreter::get();
+
+    PyObject* list = PyList_New(2);
+    PyList_SetItem(list, 0, PyFloat_FromDouble(left));
+    PyList_SetItem(list, 1, PyFloat_FromDouble(right));
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, list);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);
+    if(!res) throw std::runtime_error("Call to xlim() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+
+inline std::array<double, 2> xlim()
+{
+    PyObject* args = PyTuple_New(0);
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);
+
+    if(!res) throw std::runtime_error("Call to xlim() failed.");
+
+    Py_DECREF(res);
+
+    PyObject* left = PyTuple_GetItem(res,0);
+    PyObject* right = PyTuple_GetItem(res,1);
+    return { PyFloat_AsDouble(left), PyFloat_AsDouble(right) };
+}
+
+
+inline std::array<double, 2> ylim()
+{
+    PyObject* args = PyTuple_New(0);
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);
+
+    if(!res) throw std::runtime_error("Call to ylim() failed.");
+
+    Py_DECREF(res);
+
+    PyObject* left = PyTuple_GetItem(res,0);
+    PyObject* right = PyTuple_GetItem(res,1);
+    return { PyFloat_AsDouble(left), PyFloat_AsDouble(right) };
+}
+
+template<typename Numeric>
+inline void xticks(const std::vector<Numeric> &ticks, const std::vector<std::string> &labels = {}, const std::map<std::string, std::string>& keywords = {})
+{
+    assert(labels.size() == 0 || ticks.size() == labels.size());
+
+    detail::_interpreter::get();
+
+    // using numpy array
+    PyObject* ticksarray = detail::get_array(ticks);
+
+    PyObject* args;
+    if(labels.size() == 0) {
+        // construct positional args
+        args = PyTuple_New(1);
+        PyTuple_SetItem(args, 0, ticksarray);
+    } else {
+        // make tuple of tick labels
+        PyObject* labelstuple = PyTuple_New(labels.size());
+        for (size_t i = 0; i < labels.size(); i++)
+            PyTuple_SetItem(labelstuple, i, PyUnicode_FromString(labels[i].c_str()));
+
+        // construct positional args
+        args = PyTuple_New(2);
+        PyTuple_SetItem(args, 0, ticksarray);
+        PyTuple_SetItem(args, 1, labelstuple);
+    }
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_xticks, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if(!res) throw std::runtime_error("Call to xticks() failed");
+
+    Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void xticks(const std::vector<Numeric> &ticks, const std::map<std::string, std::string>& keywords)
+{
+    xticks(ticks, {}, keywords);
+}
+
+template<typename Numeric>
+inline void yticks(const std::vector<Numeric> &ticks, const std::vector<std::string> &labels = {}, const std::map<std::string, std::string>& keywords = {})
+{
+    assert(labels.size() == 0 || ticks.size() == labels.size());
+
+    detail::_interpreter::get();
+
+    // using numpy array
+    PyObject* ticksarray = detail::get_array(ticks);
+
+    PyObject* args;
+    if(labels.size() == 0) {
+        // construct positional args
+        args = PyTuple_New(1);
+        PyTuple_SetItem(args, 0, ticksarray);
+    } else {
+        // make tuple of tick labels
+        PyObject* labelstuple = PyTuple_New(labels.size());
+        for (size_t i = 0; i < labels.size(); i++)
+            PyTuple_SetItem(labelstuple, i, PyUnicode_FromString(labels[i].c_str()));
+
+        // construct positional args
+        args = PyTuple_New(2);
+        PyTuple_SetItem(args, 0, ticksarray);
+        PyTuple_SetItem(args, 1, labelstuple);
+    }
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_yticks, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if(!res) throw std::runtime_error("Call to yticks() failed");
+
+    Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void yticks(const std::vector<Numeric> &ticks, const std::map<std::string, std::string>& keywords)
+{
+    yticks(ticks, {}, keywords);
+}
+
+template <typename Numeric> inline void margins(Numeric margin)
+{
+    // construct positional args
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(margin));
+
+    PyObject* res =
+            PyObject_CallObject(detail::_interpreter::get().s_python_function_margins, args);
+    if (!res)
+        throw std::runtime_error("Call to margins() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+template <typename Numeric> inline void margins(Numeric margin_x, Numeric margin_y)
+{
+    // construct positional args
+    PyObject* args = PyTuple_New(2);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(margin_x));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(margin_y));
+
+    PyObject* res =
+            PyObject_CallObject(detail::_interpreter::get().s_python_function_margins, args);
+    if (!res)
+        throw std::runtime_error("Call to margins() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+
+inline void tick_params(const std::map<std::string, std::string>& keywords, const std::string axis = "both")
+{
+  detail::_interpreter::get();
+
+  // construct positional args
+  PyObject* args;
+  args = PyTuple_New(1);
+  PyTuple_SetItem(args, 0, PyString_FromString(axis.c_str()));
+
+  // construct keyword args
+  PyObject* kwargs = PyDict_New();
+  for (std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+  {
+    PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+  }
+
+
+  PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_tick_params, args, kwargs);
+
+  Py_DECREF(args);
+  Py_DECREF(kwargs);
+  if (!res) throw std::runtime_error("Call to tick_params() failed");
+
+  Py_DECREF(res);
+}
+
+inline void subplot(long nrows, long ncols, long plot_number)
+{
+    detail::_interpreter::get();
+
+    // construct positional args
+    PyObject* args = PyTuple_New(3);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(nrows));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(ncols));
+    PyTuple_SetItem(args, 2, PyFloat_FromDouble(plot_number));
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_subplot, args);
+    if(!res) throw std::runtime_error("Call to subplot() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void subplot2grid(long nrows, long ncols, long rowid=0, long colid=0, long rowspan=1, long colspan=1)
+{
+    detail::_interpreter::get();
+
+    PyObject* shape = PyTuple_New(2);
+    PyTuple_SetItem(shape, 0, PyLong_FromLong(nrows));
+    PyTuple_SetItem(shape, 1, PyLong_FromLong(ncols));
+
+    PyObject* loc = PyTuple_New(2);
+    PyTuple_SetItem(loc, 0, PyLong_FromLong(rowid));
+    PyTuple_SetItem(loc, 1, PyLong_FromLong(colid));
+
+    PyObject* args = PyTuple_New(4);
+    PyTuple_SetItem(args, 0, shape);
+    PyTuple_SetItem(args, 1, loc);
+    PyTuple_SetItem(args, 2, PyLong_FromLong(rowspan));
+    PyTuple_SetItem(args, 3, PyLong_FromLong(colspan));
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_subplot2grid, args);
+    if(!res) throw std::runtime_error("Call to subplot2grid() failed.");
+
+    Py_DECREF(shape);
+    Py_DECREF(loc);
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void title(const std::string &titlestr, const std::map<std::string, std::string> &keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* pytitlestr = PyString_FromString(titlestr.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pytitlestr);
+
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_title, args, kwargs);
+    if(!res) throw std::runtime_error("Call to title() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+inline void suptitle(const std::string &suptitlestr, const std::map<std::string, std::string> &keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* pysuptitlestr = PyString_FromString(suptitlestr.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pysuptitlestr);
+
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_suptitle, args, kwargs);
+    if(!res) throw std::runtime_error("Call to suptitle() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+inline void axis(const std::string &axisstr)
+{
+    detail::_interpreter::get();
+
+    PyObject* str = PyString_FromString(axisstr.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, str);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_axis, args);
+    if(!res) throw std::runtime_error("Call to title() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void axhline(double y, double xmin = 0., double xmax = 1., const std::map<std::string, std::string>& keywords = std::map<std::string, std::string>())
+{
+    detail::_interpreter::get();
+
+    // construct positional args
+    PyObject* args = PyTuple_New(3);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(y));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(xmin));
+    PyTuple_SetItem(args, 2, PyFloat_FromDouble(xmax));
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_axhline, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+
+    if(res) Py_DECREF(res);
+}
+
+inline void axvline(double x, double ymin = 0., double ymax = 1., const std::map<std::string, std::string>& keywords = std::map<std::string, std::string>())
+{
+    detail::_interpreter::get();
+
+    // construct positional args
+    PyObject* args = PyTuple_New(3);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(x));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(ymin));
+    PyTuple_SetItem(args, 2, PyFloat_FromDouble(ymax));
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_axvline, args, kwargs);
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+
+    if(res) Py_DECREF(res);
+}
+
+inline void axvspan(double xmin, double xmax, double ymin = 0., double ymax = 1., const std::map<std::string, std::string>& keywords = std::map<std::string, std::string>())
+{
+    // construct positional args
+    PyObject* args = PyTuple_New(4);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(xmin));
+    PyTuple_SetItem(args, 1, PyFloat_FromDouble(xmax));
+    PyTuple_SetItem(args, 2, PyFloat_FromDouble(ymin));
+    PyTuple_SetItem(args, 3, PyFloat_FromDouble(ymax));
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+      if (it->first == "linewidth" || it->first == "alpha") {
+        PyDict_SetItemString(kwargs, it->first.c_str(),
+          PyFloat_FromDouble(std::stod(it->second)));
+      } else {
+        PyDict_SetItemString(kwargs, it->first.c_str(),
+          PyString_FromString(it->second.c_str()));
+      }
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_axvspan, args, kwargs);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+
+    if(res) Py_DECREF(res);
+}
+
+inline void xlabel(const std::string &str, const std::map<std::string, std::string> &keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* pystr = PyString_FromString(str.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pystr);
+
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_xlabel, args, kwargs);
+    if(!res) throw std::runtime_error("Call to xlabel() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+inline void ylabel(const std::string &str, const std::map<std::string, std::string>& keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject* pystr = PyString_FromString(str.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pystr);
+
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_ylabel, args, kwargs);
+    if(!res) throw std::runtime_error("Call to ylabel() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+inline void set_zlabel(const std::string &str, const std::map<std::string, std::string>& keywords = {})
+{
+    detail::_interpreter::get();
+
+    // Same as with plot_surface: We lazily load the modules here the first time
+    // this function is called because I'm not sure that we can assume "matplotlib
+    // installed" implies "mpl_toolkits installed" on all platforms, and we don't
+    // want to require it for people who don't need 3d plots.
+    static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+    if (!mpl_toolkitsmod) {
+        PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+        PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+        if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+        mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+        Py_DECREF(mpl_toolkits);
+        if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+        axis3dmod = PyImport_Import(axis3d);
+        Py_DECREF(axis3d);
+        if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+    }
+
+    PyObject* pystr = PyString_FromString(str.c_str());
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pystr);
+
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject *ax =
+    PyObject_CallObject(detail::_interpreter::get().s_python_function_gca,
+      detail::_interpreter::get().s_python_empty_tuple);
+    if (!ax) throw std::runtime_error("Call to gca() failed.");
+    Py_INCREF(ax);
+
+    PyObject *zlabel = PyObject_GetAttrString(ax, "set_zlabel");
+    if (!zlabel) throw std::runtime_error("Attribute set_zlabel not found.");
+    Py_INCREF(zlabel);
+
+    PyObject *res = PyObject_Call(zlabel, args, kwargs);
+    if (!res) throw std::runtime_error("Call to set_zlabel() failed.");
+    Py_DECREF(zlabel);
+
+    Py_DECREF(ax);
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    if (res) Py_DECREF(res);
+}
+
+inline void grid(bool flag)
+{
+    detail::_interpreter::get();
+
+    PyObject* pyflag = flag ? Py_True : Py_False;
+    Py_INCREF(pyflag);
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pyflag);
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_grid, args);
+    if(!res) throw std::runtime_error("Call to grid() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void show(const bool block = true)
+{
+    detail::_interpreter::get();
+
+    PyObject* res;
+    if(block)
+    {
+        res = PyObject_CallObject(
+                detail::_interpreter::get().s_python_function_show,
+                detail::_interpreter::get().s_python_empty_tuple);
+    }
+    else
+    {
+        PyObject *kwargs = PyDict_New();
+        PyDict_SetItemString(kwargs, "block", Py_False);
+        res = PyObject_Call( detail::_interpreter::get().s_python_function_show, detail::_interpreter::get().s_python_empty_tuple, kwargs);
+       Py_DECREF(kwargs);
+    }
+
+
+    if (!res) throw std::runtime_error("Call to show() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void close()
+{
+    detail::_interpreter::get();
+
+    PyObject* res = PyObject_CallObject(
+            detail::_interpreter::get().s_python_function_close,
+            detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res) throw std::runtime_error("Call to close() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void xkcd() {
+    detail::_interpreter::get();
+
+    PyObject* res;
+    PyObject *kwargs = PyDict_New();
+
+    res = PyObject_Call(detail::_interpreter::get().s_python_function_xkcd,
+            detail::_interpreter::get().s_python_empty_tuple, kwargs);
+
+    Py_DECREF(kwargs);
+
+    if (!res)
+        throw std::runtime_error("Call to show() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void draw()
+{
+    detail::_interpreter::get();
+
+    PyObject* res = PyObject_CallObject(
+        detail::_interpreter::get().s_python_function_draw,
+        detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res) throw std::runtime_error("Call to draw() failed.");
+
+    Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void pause(Numeric interval)
+{
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyFloat_FromDouble(interval));
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_pause, args);
+    if(!res) throw std::runtime_error("Call to pause() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(res);
+}
+
+inline void save(const std::string& filename, const int dpi=0)
+{
+    detail::_interpreter::get();
+
+    PyObject* pyfilename = PyString_FromString(filename.c_str());
+
+    PyObject* args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, pyfilename);
+
+    PyObject* kwargs = PyDict_New();
+
+    if(dpi > 0)
+    {
+        PyDict_SetItemString(kwargs, "dpi", PyLong_FromLong(dpi));
+    }
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_save, args, kwargs);
+    if (!res) throw std::runtime_error("Call to save() failed.");
+
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(res);
+}
+
+inline void rcparams(const std::map<std::string, std::string>& keywords = {}) {
+    detail::_interpreter::get();
+    PyObject* args = PyTuple_New(0);
+    PyObject* kwargs = PyDict_New();
+    for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+        if ("text.usetex" == it->first)
+          PyDict_SetItemString(kwargs, it->first.c_str(), PyLong_FromLong(std::stoi(it->second.c_str())));
+        else PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+    }
+    
+    PyObject * update = PyObject_GetAttrString(detail::_interpreter::get().s_python_function_rcparams, "update");
+    PyObject * res = PyObject_Call(update, args, kwargs);
+    if(!res) throw std::runtime_error("Call to rcParams.update() failed.");
+    Py_DECREF(args);
+    Py_DECREF(kwargs);
+    Py_DECREF(update);
+    Py_DECREF(res);
+}
+
+inline void clf() {
+    detail::_interpreter::get();
+
+    PyObject *res = PyObject_CallObject(
+        detail::_interpreter::get().s_python_function_clf,
+        detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res) throw std::runtime_error("Call to clf() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void cla() {
+    detail::_interpreter::get();
+
+    PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_cla,
+                                        detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res)
+        throw std::runtime_error("Call to cla() failed.");
+
+    Py_DECREF(res);
+}
+
+inline void ion() {
+    detail::_interpreter::get();
+
+    PyObject *res = PyObject_CallObject(
+        detail::_interpreter::get().s_python_function_ion,
+        detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res) throw std::runtime_error("Call to ion() failed.");
+
+    Py_DECREF(res);
+}
+
+inline std::vector<std::array<double, 2>> ginput(const int numClicks = 1, const std::map<std::string, std::string>& keywords = {})
+{
+    detail::_interpreter::get();
+
+    PyObject *args = PyTuple_New(1);
+    PyTuple_SetItem(args, 0, PyLong_FromLong(numClicks));
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+    {
+        PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+    }
+
+    PyObject* res = PyObject_Call(
+        detail::_interpreter::get().s_python_function_ginput, args, kwargs);
+
+    Py_DECREF(kwargs);
+    Py_DECREF(args);
+    if (!res) throw std::runtime_error("Call to ginput() failed.");
+
+    const size_t len = PyList_Size(res);
+    std::vector<std::array<double, 2>> out;
+    out.reserve(len);
+    for (size_t i = 0; i < len; i++) {
+        PyObject *current = PyList_GetItem(res, i);
+        std::array<double, 2> position;
+        position[0] = PyFloat_AsDouble(PyTuple_GetItem(current, 0));
+        position[1] = PyFloat_AsDouble(PyTuple_GetItem(current, 1));
+        out.push_back(position);
+    }
+    Py_DECREF(res);
+
+    return out;
+}
+
+// Actually, is there any reason not to call this automatically for every plot?
+inline void tight_layout() {
+    detail::_interpreter::get();
+
+    PyObject *res = PyObject_CallObject(
+        detail::_interpreter::get().s_python_function_tight_layout,
+        detail::_interpreter::get().s_python_empty_tuple);
+
+    if (!res) throw std::runtime_error("Call to tight_layout() failed.");
+
+    Py_DECREF(res);
+}
+
+// Support for variadic plot() and initializer lists:
+
+namespace detail {
+
+template<typename T>
+using is_function = typename std::is_function<std::remove_pointer<std::remove_reference<T>>>::type;
+
+template<bool obj, typename T>
+struct is_callable_impl;
+
+template<typename T>
+struct is_callable_impl<false, T>
+{
+    typedef is_function<T> type;
+}; // a non-object is callable iff it is a function
+
+template<typename T>
+struct is_callable_impl<true, T>
+{
+    struct Fallback { void operator()(); };
+    struct Derived : T, Fallback { };
+
+    template<typename U, U> struct Check;
+
+    template<typename U>
+    static std::true_type test( ... ); // use a variadic function to make sure (1) it accepts everything and (2) its always the worst match
+
+    template<typename U>
+    static std::false_type test( Check<void(Fallback::*)(), &U::operator()>* );
+
+public:
+    typedef decltype(test<Derived>(nullptr)) type;
+    typedef decltype(&Fallback::operator()) dtype;
+    static constexpr bool value = type::value;
+}; // an object is callable iff it defines operator()
+
+template<typename T>
+struct is_callable
+{
+    // dispatch to is_callable_impl<true, T> or is_callable_impl<false, T> depending on whether T is of class type or not
+    typedef typename is_callable_impl<std::is_class<T>::value, T>::type type;
+};
+
+template<typename IsYDataCallable>
+struct plot_impl { };
+
+template<>
+struct plot_impl<std::false_type>
+{
+    template<typename IterableX, typename IterableY>
+    bool operator()(const IterableX& x, const IterableY& y, const std::string& format)
+    {
+        detail::_interpreter::get();
+
+        // 2-phase lookup for distance, begin, end
+        using std::distance;
+        using std::begin;
+        using std::end;
+
+        auto xs = distance(begin(x), end(x));
+        auto ys = distance(begin(y), end(y));
+        assert(xs == ys && "x and y data must have the same number of elements!");
+
+        PyObject* xlist = PyList_New(xs);
+        PyObject* ylist = PyList_New(ys);
+        PyObject* pystring = PyString_FromString(format.c_str());
+
+        auto itx = begin(x), ity = begin(y);
+        for(size_t i = 0; i < xs; ++i) {
+            PyList_SetItem(xlist, i, PyFloat_FromDouble(*itx++));
+            PyList_SetItem(ylist, i, PyFloat_FromDouble(*ity++));
+        }
+
+        PyObject* plot_args = PyTuple_New(3);
+        PyTuple_SetItem(plot_args, 0, xlist);
+        PyTuple_SetItem(plot_args, 1, ylist);
+        PyTuple_SetItem(plot_args, 2, pystring);
+
+        PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_plot, plot_args);
+
+        Py_DECREF(plot_args);
+        if(res) Py_DECREF(res);
+
+        return res;
+    }
+};
+
+template<>
+struct plot_impl<std::true_type>
+{
+    template<typename Iterable, typename Callable>
+    bool operator()(const Iterable& ticks, const Callable& f, const std::string& format)
+    {
+        if(begin(ticks) == end(ticks)) return true;
+
+        // We could use additional meta-programming to deduce the correct element type of y,
+        // but all values have to be convertible to double anyways
+        std::vector<double> y;
+        for(auto x : ticks) y.push_back(f(x));
+        return plot_impl<std::false_type>()(ticks,y,format);
+    }
+};
+
+} // end namespace detail
+
+// recursion stop for the above
+template<typename... Args>
+bool plot() { return true; }
+
+template<typename A, typename B, typename... Args>
+bool plot(const A& a, const B& b, const std::string& format, Args... args)
+{
+    return detail::plot_impl<typename detail::is_callable<B>::type>()(a,b,format) && plot(args...);
+}
+
+/*
+ * This group of plot() functions is needed to support initializer lists, i.e. calling
+ *    plot( {1,2,3,4} )
+ */
+inline bool plot(const std::vector<double>& x, const std::vector<double>& y, const std::string& format = "") {
+    return plot<double,double>(x,y,format);
+}
+
+inline bool plot(const std::vector<double>& y, const std::string& format = "") {
+    return plot<double>(y,format);
+}
+
+inline bool plot(const std::vector<double>& x, const std::vector<double>& y, const std::map<std::string, std::string>& keywords) {
+    return plot<double>(x,y,keywords);
+}
+
+/*
+ * This class allows dynamic plots, ie changing the plotted data without clearing and re-plotting
+ */
+class Plot
+{
+public:
+    // default initialization with plot label, some data and format
+    template<typename Numeric>
+    Plot(const std::string& name, const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::string& format = "") {
+        detail::_interpreter::get();
+
+        assert(x.size() == y.size());
+
+        PyObject* kwargs = PyDict_New();
+        if(name != "")
+            PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+        PyObject* xarray = detail::get_array(x);
+        PyObject* yarray = detail::get_array(y);
+
+        PyObject* pystring = PyString_FromString(format.c_str());
+
+        PyObject* plot_args = PyTuple_New(3);
+        PyTuple_SetItem(plot_args, 0, xarray);
+        PyTuple_SetItem(plot_args, 1, yarray);
+        PyTuple_SetItem(plot_args, 2, pystring);
+
+        PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);
+
+        Py_DECREF(kwargs);
+        Py_DECREF(plot_args);
+
+        if(res)
+        {
+            line= PyList_GetItem(res, 0);
+
+            if(line)
+                set_data_fct = PyObject_GetAttrString(line,"set_data");
+            else
+                Py_DECREF(line);
+            Py_DECREF(res);
+        }
+    }
+
+    // shorter initialization with name or format only
+    // basically calls line, = plot([], [])
+    Plot(const std::string& name = "", const std::string& format = "")
+        : Plot(name, std::vector<double>(), std::vector<double>(), format) {}
+
+    template<typename Numeric>
+    bool update(const std::vector<Numeric>& x, const std::vector<Numeric>& y) {
+        assert(x.size() == y.size());
+        if(set_data_fct)
+        {
+            PyObject* xarray = detail::get_array(x);
+            PyObject* yarray = detail::get_array(y);
+
+            PyObject* plot_args = PyTuple_New(2);
+            PyTuple_SetItem(plot_args, 0, xarray);
+            PyTuple_SetItem(plot_args, 1, yarray);
+
+            PyObject* res = PyObject_CallObject(set_data_fct, plot_args);
+            if (res) Py_DECREF(res);
+            return res;
+        }
+        return false;
+    }
+
+    // clears the plot but keep it available
+    bool clear() {
+        return update(std::vector<double>(), std::vector<double>());
+    }
+
+    // definitely remove this line
+    void remove() {
+        if(line)
+        {
+            auto remove_fct = PyObject_GetAttrString(line,"remove");
+            PyObject* args = PyTuple_New(0);
+            PyObject* res = PyObject_CallObject(remove_fct, args);
+            if (res) Py_DECREF(res);
+        }
+        decref();
+    }
+
+    ~Plot() {
+        decref();
+    }
+private:
+
+    void decref() {
+        if(line)
+            Py_DECREF(line);
+        if(set_data_fct)
+            Py_DECREF(set_data_fct);
+    }
+
+
+    PyObject* line = nullptr;
+    PyObject* set_data_fct = nullptr;
+};
+
+} // end namespace matplotlibcpp