Feat/return proxy

gallery/artist_animation/animate_decay.cpp

@@ -27,9 +27,8 @@ int main() {
     auto [xmin, xmax] = ax.get_xlim();
     if (t >= xmax)
       ax.set_xlim(Args(xmin, 2 * xmax));
-    py::object line =
-        ax.plot(Args(ts, ys), Kwargs("color"_a = "blue", "lw"_a = 1));
-    artist_list.append(line);
+    auto line = ax.plot(Args(ts, ys), Kwargs("color"_a = "blue", "lw"_a = 1));
+    artist_list.append(line.unwrap());
   }
   auto ani = ArtistAnimation(Args(fig.unwrap(), artist_list),
                              Kwargs("interval"_a = 10));

gallery/artist_animation/random_walk.cpp

@@ -1,7 +1,9 @@
 // example from https://matplotlib.org/stable/gallery/animation/random_walk.html
 
+#include <matplotlibcpp17/axes.h>
 #include <matplotlibcpp17/pyplot.h>
 #include <matplotlibcpp17/animation.h>
+#include <matplotlibcpp17/mplot3d.h>
 
 #include <xtensor/xrandom.hpp>
 #include <xtensor/xbuilder.hpp>
@@ -32,21 +34,23 @@ int main() {
   }
   py::scoped_interpreter guard{};
   auto plt = matplotlibcpp17::pyplot::import();
+  // this is required for "projection = 3d"
+  matplotlibcpp17::mplot3d::import();
   auto fig = plt.figure();
   auto ax = fig.add_subplot(py::make_tuple(), Kwargs("projection"_a = "3d"));
   py::list artist_list;
   for (int j = 1; j <= num_steps; ++j) {
     for (int i = 0; i < M; ++i) {
-      auto xs0 = xt::view(walks, i, 0, xt::range(1, j + 1));
-      auto ys0 = xt::view(walks, i, 1, xt::range(1, j + 1));
-      auto zs0 = xt::view(walks, i, 2, xt::range(1, j + 1));
+      const auto xs0 = xt::view(walks, i, 0, xt::range(1, j + 1));
+      const auto ys0 = xt::view(walks, i, 1, xt::range(1, j + 1));
+      const auto zs0 = xt::view(walks, i, 2, xt::range(1, j + 1));
       // to vector
       vector<double> xs(xs0.begin(), xs0.end());
       vector<double> ys(ys0.begin(), ys0.end());
       vector<double> zs(zs0.begin(), zs0.end());
       ax.plot(Args(xs, ys, zs), Kwargs("color"_a = colors[i]));
     }
-    artist_list.append(ax.get_lines());
+    artist_list.append(ax.get_lines().unwrap());
   }
   auto ani = ArtistAnimation(Args(fig.unwrap(), artist_list),
                              Kwargs("interval"_a = 100));

gallery/images_contours_and_fields/contourf_log.cpp

@@ -19,12 +19,12 @@ using mesh2D = vector<vector<double>>;
 
 int main() {
   const int N = 100;
-  auto x_ = xt::linspace(-3.0, 3.0, N);
-  auto y_ = xt::linspace(-2.0, 2.0, N);
+  const auto x_ = xt::linspace(-3.0, 3.0, N);
+  const auto y_ = xt::linspace(-2.0, 2.0, N);
 
-  auto [X_, Y_] = xt::meshgrid(x_, y_);
-  auto Z1_ = xt::exp(-xt::pow(X_, 2) - xt::pow(Y_, 2));
-  auto Z2_ = xt::exp(-xt::pow(X_ * 10, 2) - xt::pow(Y_ * 10, 2));
+  const auto [X_, Y_] = xt::meshgrid(x_, y_);
+  const auto Z1_ = xt::exp(-xt::pow(X_, 2) - xt::pow(Y_, 2));
+  const auto Z2_ = xt::exp(-xt::pow(X_ * 10, 2) - xt::pow(Y_ * 10, 2));
   xt::xarray<double> z_ = Z1_ + 50 * Z2_;
   // instead of x[:5, :5] = -1.0
   auto v = xt::view(z_, xt::range(_, 5), xt::range(_, 5));
@@ -45,14 +45,14 @@ int main() {
 
   py::scoped_interpreter guard{};
   // to numpy array
-  auto Xpy = py::array(py::cast(std::move(X)));
-  auto Ypy = py::array(py::cast(std::move(Y)));
-  auto zpy = py::array(py::cast(std::move(z)));
+  const auto Xpy = py::array(py::cast(std::move(X)));
+  const auto Ypy = py::array(py::cast(std::move(Y)));
+  const auto zpy = py::array(py::cast(std::move(z)));
   auto plt = pyplot::import();
   auto [fig, ax] = plt.subplots();
   auto cs = ax.contourf(Args(Xpy, Ypy, zpy),
                         Kwargs("locator"_a = ticker::LogLocator().unwrap(),
                                "cmap"_a = cm::PuBu_r));
-  fig.colorbar(Args(cs));
+  fig.colorbar(Args(cs.unwrap()));
   plt.show();
 }

gallery/images_contours_and_fields/image_demo.cpp

@@ -19,10 +19,10 @@ using mesh2D = vector<vector<double>>;
 int main() {
   const double delta = 0.025;
   const auto x = xt::arange<double>(-3.0, 3.0, delta);
-  auto [X_, Y_] = xt::meshgrid(x, x);
-  auto Z1_ = xt::exp(-xt::pow(X_, 2) - xt::pow(Y_, 2));
-  auto Z2_ = xt::exp(-xt::pow(X_ - 1, 2) - xt::pow(Y_ - 1, 2));
-  auto Z_ = (Z1_ - Z2_) * 2.0;
+  const auto [X_, Y_] = xt::meshgrid(x, x);
+  const auto Z1_ = xt::exp(-xt::pow(X_, 2) - xt::pow(Y_, 2));
+  const auto Z2_ = xt::exp(-xt::pow(X_ - 1, 2) - xt::pow(Y_ - 1, 2));
+  const auto Z_ = (Z1_ - Z2_) * 2.0;
 
   // to vector
   vector<double> X(X_.begin(), X_.end()), Y(Y_.begin(), Y_.end()),
@@ -42,7 +42,7 @@ int main() {
   auto [fig, ax] = plt.subplots();
   const double vmax = *max_element(Z_.begin(), Z_.end()),
                vmin = *min_element(Z_.begin(), Z_.end());
-  auto Zpy = py::array(py::cast(std::move(Z2D)));
+  const auto Zpy = py::array(py::cast(std::move(Z2D)));
   ax.imshow(Args(Zpy), Kwargs("interpolation"_a = "bilinear",
                               "cmap"_a = cm::RdYlGn, "origin"_a = "lower",
                               "extent"_a = py::make_tuple(-3, 3, -3, 3),

gallery/images_contours_and_fields/quiver_demo.cpp

@@ -14,10 +14,10 @@ using namespace std;
 using namespace matplotlibcpp17;
 
 int main1() {
-  auto [X0, Y0] = xt::meshgrid(xt::arange<double>(0.0, 2 * M_PI, 0.2),
-                               xt::arange<double>(0.0, 2 * M_PI, 0.2));
-  auto U0 = xt::cos(X0);
-  auto V0 = xt::sin(Y0);
+  const auto [X0, Y0] = xt::meshgrid(xt::arange<double>(0.0, 2 * M_PI, 0.2),
+                                     xt::arange<double>(0.0, 2 * M_PI, 0.2));
+  const auto U0 = xt::cos(X0);
+  const auto V0 = xt::sin(Y0);
   // to vector
   vector<double> X(X0.begin(), X0.end()), Y(Y0.begin(), Y0.end()),
       U(U0.begin(), U0.end()), V(V0.begin(), V0.end());
@@ -38,10 +38,10 @@ int main1() {
 }
 
 int main2() {
-  auto [X0, Y0] = xt::meshgrid(xt::arange<double>(0.0, 2 * M_PI, 0.6),
-                               xt::arange<double>(0.0, 2 * M_PI, 0.6));
-  auto U0 = xt::cos(X0);
-  auto V0 = xt::sin(Y0);
+  const auto [X0, Y0] = xt::meshgrid(xt::arange<double>(0.0, 2 * M_PI, 0.6),
+                                     xt::arange<double>(0.0, 2 * M_PI, 0.6));
+  const auto U0 = xt::cos(X0);
+  const auto V0 = xt::sin(Y0);
   // to vector
   vector<double> X(X0.begin(), X0.end()), Y(Y0.begin(), Y0.end()),
       U(U0.begin(), U0.end()), V(V0.begin(), V0.end());
@@ -65,11 +65,11 @@ int main2() {
 }
 
 int main3() {
-  auto [X0, Y0] = xt::meshgrid(xt::arange<double>(0.0, 2 * M_PI, 0.2),
-                               xt::arange<double>(0.0, 2 * M_PI, 0.2));
-  auto U0 = xt::cos(X0);
-  auto V0 = xt::sin(Y0);
-  auto M0 = xt::hypot(U0, V0);
+  const auto [X0, Y0] = xt::meshgrid(xt::arange<double>(0.0, 2 * M_PI, 0.2),
+                                     xt::arange<double>(0.0, 2 * M_PI, 0.2));
+  const auto U0 = xt::cos(X0);
+  const auto V0 = xt::sin(Y0);
+  const auto M0 = xt::hypot(U0, V0);
   vector<double> X(X0.begin(), X0.end()), Y(Y0.begin(), Y0.end()),
       U(U0.begin(), U0.end()), V(V0.begin(), V0.end()), M(M0.begin(), M0.end());
 

gallery/lines_bars_and_markers/bar_label_demo.cpp

@@ -11,11 +11,11 @@ using namespace std;
 using namespace matplotlibcpp17;
 
 int main1() {
-  vector<int> menMeans = {20, 35, 30, 35, -27};
-  vector<int> womenMeans = {25, 32, 34, 20, -25};
-  vector<int> menStd = {2, 3, 4, 1, 2};
-  vector<int> womenStd = {3, 5, 2, 3, 3};
-  vector<int> ind = {0, 1, 2, 3, 4}; // the x locations for the groups
+  const vector<int> menMeans = {20, 35, 30, 35, -27};
+  const vector<int> womenMeans = {25, 32, 34, 20, -25};
+  const vector<int> menStd = {2, 3, 4, 1, 2};
+  const vector<int> womenStd = {3, 5, 2, 3, 3};
+  const vector<int> ind = {0, 1, 2, 3, 4}; // the x locations for the groups
   const double width =
       0.35; // the width of the bars: can also be len(x) sequence
   auto plt = matplotlibcpp17::pyplot::import();
@@ -44,12 +44,12 @@ int main1() {
 }
 
 int main2() {
-  vector<string> people = {"Tom", "Dick", "Harry", "Slim", "Jim"};
-  vector<int> y_pos = {0, 1, 2, 3, 4};
-  vector<double> performance = {10.00367304, 10.42750809, 10.09280011,
-                                8.66745522, 12.77785333};
-  vector<double> error = {0.70633485, 0.24791576, 0.15788335, 0.69769852,
-                          0.71995667};
+  const vector<string> people = {"Tom", "Dick", "Harry", "Slim", "Jim"};
+  const vector<int> y_pos = {0, 1, 2, 3, 4};
+  const vector<double> performance = {10.00367304, 10.42750809, 10.09280011,
+                                      8.66745522, 12.77785333};
+  const vector<double> error = {0.70633485, 0.24791576, 0.15788335, 0.69769852,
+                                0.71995667};
   auto plt = matplotlibcpp17::pyplot::import();
   auto [fig, ax] = plt.subplots();
   auto hbars = ax.barh(Args(y_pos, performance),
@@ -71,12 +71,12 @@ int main2() {
 }
 
 int main3() {
-  vector<string> people = {"Tom", "Dick", "Harry", "Slim", "Jim"};
-  vector<int> y_pos = {0, 1, 2, 3, 4};
-  vector<double> performance = {10.00367304, 10.42750809, 10.09280011,
-                                8.66745522, 12.77785333};
-  vector<double> error = {0.70633485, 0.24791576, 0.15788335, 0.69769852,
-                          0.71995667};
+  const vector<string> people = {"Tom", "Dick", "Harry", "Slim", "Jim"};
+  const vector<int> y_pos = {0, 1, 2, 3, 4};
+  const vector<double> performance = {10.00367304, 10.42750809, 10.09280011,
+                                      8.66745522, 12.77785333};
+  const vector<double> error = {0.70633485, 0.24791576, 0.15788335, 0.69769852,
+                                0.71995667};
   auto plt = matplotlibcpp17::pyplot::import();
   auto [fig, ax] = plt.subplots();
   auto hbars = ax.barh(Args(y_pos, performance),

gallery/lines_bars_and_markers/errorbar_limits_simple.cpp

@@ -15,11 +15,11 @@ int main() {
   py::scoped_interpreter guard{};
   auto plt = pyplot::import();
   auto fig = plt.figure();
-  auto x_ = xt::arange(0.0, 10.0, 1.0);
-  auto y_ = 2.5 * xt::sin(x_ / 20 * M_PI);
-  auto y1_ = y_ + 1.0, y2_ = y_ + 2.0, y3_ = y_ + 3.0;
-  auto yerr_ = xt::linspace(0.05, 0.2, 10);
-  vector<double> x(x_.begin(), x_.end()), y(y_.begin(), y_.end()),
+  const auto x_ = xt::arange(0.0, 10.0, 1.0);
+  const auto y_ = 2.5 * xt::sin(x_ / 20 * M_PI);
+  const auto y1_ = y_ + 1.0, y2_ = y_ + 2.0, y3_ = y_ + 3.0;
+  const auto yerr_ = xt::linspace(0.05, 0.2, 10);
+  const vector<double> x(x_.begin(), x_.end()), y(y_.begin(), y_.end()),
       yerr(yerr_.begin(), yerr_.end()), y3(y3_.begin(), y3_.end()),
       y2(y2_.begin(), y2_.end()), y1(y1_.begin(), y1_.end());
   plt.errorbar(Args(x, y3),

gallery/lines_bars_and_markers/errorbar_subsample.cpp

@@ -12,12 +12,12 @@ using namespace std;
 using namespace matplotlibcpp17;
 
 int main() {
-  auto x_ = xt::arange(0.1, 4.0, 0.1);
-  auto y1_ = xt::exp(-1.0 * x_);
-  auto y2_ = xt::exp(-0.5 * x_);
-  auto y1err_ = 0.1 + 0.1 * xt::sqrt(x_);
-  auto y2err_ = 0.1 + 0.1 * xt::sqrt(x_ / 2.0);
-  vector<double> x(x_.begin(), x_.end()), y1(y1_.begin(), y1_.end()),
+  const auto x_ = xt::arange(0.1, 4.0, 0.1);
+  const auto y1_ = xt::exp(-1.0 * x_);
+  const auto y2_ = xt::exp(-0.5 * x_);
+  const auto y1err_ = 0.1 + 0.1 * xt::sqrt(x_);
+  const auto y2err_ = 0.1 + 0.1 * xt::sqrt(x_ / 2.0);
+  const vector<double> x(x_.begin(), x_.end()), y1(y1_.begin(), y1_.end()),
       y2(y2_.begin(), y2_.end()), y1err(y1err_.begin(), y1err_.end()),
       y2err(y2err_.begin(), y2err_.end());
 
@@ -34,11 +34,14 @@ int main() {
   ax1.errorbar(Args(x, y1), Kwargs("yerr"_a = y1err, "errorevery"_a = 6));
   ax1.errorbar(Args(x, y2), Kwargs("yerr"_a = y2err, "errorevery"_a = 6));
 
+  // TODO: TypeError: '<' not supported between instances of 'tuple' and 'int'
+  /*
   ax2.set_title(Args("second seris shifted by 3"));
   ax2.errorbar(Args(x, y1),
                Kwargs("yerr"_a = y1err, "errorevery"_a = py::make_tuple(0, 6)));
   ax2.errorbar(Args(x, y2),
                Kwargs("yerr"_a = y2err, "errorevery"_a = py::make_tuple(3, 6)));
+  */
 
   fig.suptitle(Args("Errorbar subsampling"));
 #if USE_GUI

gallery/lines_bars_and_markers/fill.cpp

@@ -13,10 +13,10 @@ using namespace matplotlibcpp17;
 int main() {
   const double scale = 10;
   const xt::xarray<double> angles = {90.0, 210.0, 330.0};
-  auto x0 = scale / sqrt(3.0) * xt::cos(angles / 360.0 * 2 * M_PI);
-  auto y0 = scale / sqrt(3.0) * xt::sin(angles / 360.0 * 2 * M_PI);
-  vector<double> x(x0.begin(), x0.end());
-  vector<double> y(y0.begin(), y0.end());
+  const auto x0 = scale / sqrt(3.0) * xt::cos(angles / 360.0 * 2 * M_PI);
+  const auto y0 = scale / sqrt(3.0) * xt::sin(angles / 360.0 * 2 * M_PI);
+  const vector<double> x(x0.begin(), x0.end());
+  const vector<double> y(y0.begin(), y0.end());
 
   py::scoped_interpreter guard{};
   auto plt = matplotlibcpp17::pyplot::import();

gallery/lines_bars_and_markers/fill_between_demo.cpp

@@ -14,10 +14,10 @@ using namespace std;
 using namespace matplotlibcpp17;
 
 int main1() {
-  auto x_ = xt::arange(0.0, 2.0, 0.01);
-  auto y1_ = xt::sin(2 * M_PI * x_);
-  auto y2_ = 0.8 * xt::sin(4 * M_PI * x_);
-  vector<double> x(x_.begin(), x_.end()), y1(y1_.begin(), y1_.end()),
+  const auto x_ = xt::arange(0.0, 2.0, 0.01);
+  const auto y1_ = xt::sin(2 * M_PI * x_);
+  const auto y2_ = 0.8 * xt::sin(4 * M_PI * x_);
+  const vector<double> x(x_.begin(), x_.end()), y1(y1_.begin(), y1_.end()),
       y2(y2_.begin(), y2_.end());
 
   auto plt = matplotlibcpp17::pyplot::import();
@@ -45,9 +45,9 @@ int main1() {
 int main2() {
   auto plt = matplotlibcpp17::pyplot::import();
 
-  vector<double> x = {0, 1, 2, 3};
-  vector<double> y1 = {0.8, 0.8, 0.2, 0.2};
-  vector<double> y2 = {0, 0, 1, 1};
+  const vector<double> x = {0, 1, 2, 3};
+  const vector<double> y1 = {0.8, 0.8, 0.2, 0.2};
+  const vector<double> y2 = {0, 0, 1, 1};
   auto [fig, axs] = plt.subplots(2, 1, Kwargs("sharex"_a = true));
   auto ax1 = axs[0], ax2 = axs[1];
 
@@ -85,8 +85,8 @@ int main3() {
   auto plt = matplotlibcpp17::pyplot::import();
   auto [fig, ax] = plt.subplots();
 
-  auto x0 = xt::arange(0.0, 4 * M_PI, 0.01);
-  auto y0 = xt::sin(x0);
+  const auto x0 = xt::arange(0.0, 4 * M_PI, 0.01);
+  const auto y0 = xt::sin(x0);
   vector<double> x(x0.begin(), x0.end()), y(y0.begin(), y0.end());
   ax.plot(Args(x, y), Kwargs("color"_a = "black"));
   const double threshold = 0.75;
@@ -96,7 +96,7 @@ int main3() {
   ax.fill_between(Args(x, 0, 1),
                   Kwargs("where"_a = where, "color"_a = "green",
                          "alpha"_a = 0.5,
-                         "transform"_a = ax.get_xaxis_transform()));
+                         "transform"_a = ax.get_xaxis_transform().unwrap()));
 #if USE_GUI
   plt.show();
 #else

gallery/lines_bars_and_markers/fill_betweenx_demo.cpp

@@ -13,10 +13,10 @@ using namespace matplotlibcpp17;
 
 int main1() {
   auto plt = matplotlibcpp17::pyplot::import();
-  auto y_ = xt::arange(0.0, 2.0, 0.01);
-  auto x1_ = xt::sin(2 * M_PI * y_);
-  auto x2_ = 1.2 * xt::sin(4 * M_PI * y_);
-  vector<double> y(y_.begin(), y_.end()), x1(x1_.begin(), x1_.end()),
+  const auto y_ = xt::arange(0.0, 2.0, 0.01);
+  const auto x1_ = xt::sin(2 * M_PI * y_);
+  const auto x2_ = 1.2 * xt::sin(4 * M_PI * y_);
+  const vector<double> y(y_.begin(), y_.end()), x1(x1_.begin(), x1_.end()),
       x2(x2_.begin(), x2_.end());
 
   auto [fig, axes] = plt.subplots(

gallery/lines_bars_and_markers/scatter_hist.cpp

@@ -14,9 +14,9 @@ using namespace matplotlibcpp17;
 
 int main() {
   int N = 1000;
-  auto x_ = xt::random::randn<double>({N});
-  auto y_ = xt::random::randn<double>({N});
-  vector<double> x(x_.begin(), x_.end()), y(y_.begin(), y_.end());
+  const auto x_ = xt::random::randn<double>({N});
+  const auto y_ = xt::random::randn<double>({N});
+  const vector<double> x(x_.begin(), x_.end()), y(y_.begin(), y_.end());
   py::scoped_interpreter guard{};
   auto plt = matplotlibcpp17::pyplot::import();
   // cell1
@@ -40,7 +40,8 @@ int main() {
     ax_histy.tick_params(Args(), Kwargs("axis"_a = "y", "labelleft"_a = false));
     ax.scatter(Args(x, y));
     const double binwidth = 0.25;
-    auto xi = xt::amax(xt::fabs(x_), {0}), yi = xt::amax(xt::fabs(y_), {0});
+    const auto xi = xt::amax(xt::fabs(x_), {0}),
+               yi = xt::amax(xt::fabs(y_), {0});
     const double xymax = max(fabs(x_[xi]), fabs(y_[yi]));
     const double lim = (static_cast<int>(xymax / binwidth) + 1) * binwidth;
     auto bins_ = xt::arange(-lim, lim + binwidth, binwidth);
@@ -73,7 +74,8 @@ int main() {
     ax_histy.tick_params(Args(), Kwargs("axis"_a = "y", "labelleft"_a = false));
     ax.scatter(Args(x, y));
     const double binwidth = 0.25;
-    auto xi = xt::amax(xt::fabs(x_), {0}), yi = xt::amax(xt::fabs(y_), {0});
+    const auto xi = xt::amax(xt::fabs(x_), {0}),
+               yi = xt::amax(xt::fabs(y_), {0});
     const double xymax = max(fabs(x_[xi]), fabs(y_[yi]));
     const double lim = (static_cast<int>(xymax / binwidth) + 1) * binwidth;
     auto bins_ = xt::arange(-lim, lim + binwidth, binwidth);

gallery/lines_bars_and_markers/scatter_symbol.cpp

@@ -23,16 +23,16 @@ using namespace matplotlibcpp17;
 int main() {
   py::scoped_interpreter guard{};
   auto plt = pyplot::import();
-  vector<double> x = {0.,  2.,  4.,  6.,  8.,  10., 12., 14., 16.,
-                      18., 20., 22., 24., 26., 28., 30., 32., 34.,
-                      36., 38., 40., 42., 44., 46., 48.};
-  vector<double> y = {
+  const vector<double> x = {0.,  2.,  4.,  6.,  8.,  10., 12., 14., 16.,
+                            18., 20., 22., 24., 26., 28., 30., 32., 34.,
+                            36., 38., 40., 42., 44., 46., 48.};
+  const vector<double> y = {
       21.01101912,  24.74481311,  27.34126659,  27.27298483,  44.26208785,
       41.14266853,  32.72670355,  35.63706738,  57.689303,    64.43917295,
       56.86145395,  65.85596686,  91.33222544,  89.93319308,  90.07761828,
       104.3101143,  105.86324421, 125.79378295, 127.67869682, 131.83987721,
       140.51644988, 140.79566887, 153.22398837, 169.06951457, 174.97156606};
-  vector<double> s = {
+  const vector<double> s = {
       736.2911849,   628.75670445,  664.90041181,  607.46030945, 884.4840139,
       774.0174507,   790.37543212,  1278.33411095, 588.75488929, 810.61127126,
       1126.45270023, 1278.31780809, 886.56768427,  769.13688434, 953.93522899,