timeseries plot functionality

Author: amadeus84

CMakeLists.txt

@@ -110,6 +110,11 @@ if(Python3_NumPy_FOUND)
   target_compile_features(ranges PRIVATE cxx_std_20)
   set_target_properties(ranges PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
 
+  add_executable(timeseries examples/timeseries.cpp)
+  target_link_libraries(timeseries PRIVATE matplotlib_cpp)
+  target_compile_features(timeseries PRIVATE cxx_std_20)
+  set_target_properties(timeseries PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+
 endif()
 
 

datetime_utils.h

@@ -0,0 +1,137 @@
+#pragma once
+
+#include "matplotlibcpp.h"
+
+#include <Python.h>
+#include <datetime.h>
+
+#include <string>
+#include <cstdlib>
+#include <map>
+#include <ranges>
+
+// Convenience functions for converting C/C++ time objects to datetime.datetime
+// objects. These are outside the matplotlibcpp namespace because they do not
+// exist in matplotlib.pyplot.
+template<class TimePoint>
+PyObject* toPyDateTime(const TimePoint& t, int dummy=0)
+{
+    using namespace std::chrono;
+    auto tsec=time_point_cast<seconds>(t);
+    auto us=duration_cast<microseconds>(t-tsec);
+
+    time_t tt=system_clock::to_time_t(t);
+    PyObject* obj=toPyDateTime(tt, us.count());
+
+    return obj;
+}
+
+template <>
+PyObject* toPyDateTime(const time_t& t, int us)
+{
+    tm tm {};
+    gmtime_r(&t,&tm);         // compatible with matlab, inverse of datenum.
+
+    if (!PyDateTimeAPI) {
+	PyDateTime_IMPORT;
+    }
+
+    PyObject* obj=PyDateTime_FromDateAndTime(tm.tm_year+1900,
+					     tm.tm_mon+1,
+					     tm.tm_mday,
+					     tm.tm_hour,
+					     tm.tm_min,
+					     tm.tm_sec,
+					     us);
+    if (obj) {
+	PyDateTime_Check(obj);
+	Py_INCREF(obj);
+    }
+
+    return obj;
+}
+
+template <class Time_t>
+PyObject* toPyDateTimeList(const Time_t* t, size_t nt)
+{
+    PyObject* tlist=PyList_New(nt);
+    if (tlist==nullptr)
+	return nullptr;
+
+    // Py_INCREF(tlist);
+
+    if (!PyDateTimeAPI) {
+	PyDateTime_IMPORT;
+    }
+
+    for (size_t i=0; i<nt; i++) {
+	PyObject* ti=toPyDateTime(t[i], 0);
+	PyList_SET_ITEM(tlist, i, ti);
+    }
+
+    return tlist;
+}
+
+template <class Time_t>
+class DateTimeList
+{
+public:
+
+    DateTimeList(const Time_t* t, size_t nt) {
+	tlist=(PyListObject*) toPyDateTimeList(t, nt);
+    }
+
+    ~DateTimeList() { if (tlist) Py_DECREF((PyObject*) tlist); }
+
+    PyListObject* get() const { return tlist; }
+    size_t size() const { return tlist ? PyList_Size((PyObject*)tlist) : 0; }
+
+private:
+    mutable PyListObject* tlist=nullptr;
+};
+
+
+
+namespace matplotlibcpp {
+
+// special purpose function to plot against python datetime objects.
+template <class Time_t, std::ranges::contiguous_range ContainerY>
+bool plot(const DateTimeList<Time_t>& t, const ContainerY& y,
+	  const std::string& fmt="")
+{
+    detail::_interpreter::get();
+
+    // DECREF decrements the ref counts of all objects in the plot_args tuple,
+    // In particular, it decreasesthe ref count of the time array x.
+    // We want to maintain that unchanged though, so we can reuse it.
+    PyListObject* tarray=t.get();
+    Py_INCREF(tarray);
+
+    NPY_TYPES ytype=detail::select_npy_type<typename ContainerY::value_type>::type;
+
+    npy_intp tsize=PyList_Size((PyObject*)tarray);
+    assert(y.size()%tsize == 0 && "length of y must be a multiple of length of x!");
+
+    npy_intp yrows=tsize, ycols=y.size()/yrows;
+    npy_intp ysize[]={yrows, ycols};   // ysize[0] must equal tsize
+
+    PyObject* yarray = PyArray_New(&PyArray_Type,
+				   2, ysize, ytype, nullptr, (void*) y.data(),
+				   0, NPY_ARRAY_FARRAY, nullptr);  // col major
+
+    PyObject* pystring = PyString_FromString(fmt.c_str());
+
+    PyObject* plot_args = PyTuple_New(3);
+    PyTuple_SetItem(plot_args, 0, (PyObject*)tarray);
+    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 true;
+}
+
+}

examples/timeseries.cpp

@@ -0,0 +1,97 @@
+//
+// g++ -std=c++20 -g -Wall -o timeseries $(python-config --includes) timeseries.cpp $(python-config --ldflags --embed)
+// g++ -std=c++20 -g -Wall -fsanitize=address -o timeseries $(python-config --includes) timeseries.cpp $(python-config --ldflags --embed) -lasan
+//
+#include "../matplotlibcpp.h"
+#include "../datetime_utils.h"
+
+#include <cassert>
+#include <iostream>
+#include <cstdlib>
+#include <vector>
+#include <string>
+
+using namespace std;
+namespace plt = matplotlibcpp;
+
+// In python2.7 there was a dedicated function PyString_AsString, but no more.
+string tostring(PyObject* obj)
+{
+    string out;
+    PyObject* repr=PyObject_Repr(obj);   // unicode object
+    if (repr) {
+	PyObject* str=PyUnicode_AsEncodedString(repr, 0, 0);
+	if (str) {
+	    const char* bytes=PyBytes_AS_STRING(str);
+	    out=bytes;
+	    Py_DECREF(str);
+	}
+
+	Py_DECREF(repr);
+    }
+
+    return out;
+}
+
+int main()
+{
+    using namespace std::chrono;
+    using clk=std::chrono::high_resolution_clock;
+
+    plt::detail::_interpreter::get();       // initialize everything
+
+    // Test toPyDateTime functions.
+    PyObject* now=toPyDateTime(time(0));
+    cout << tostring(now) << endl;
+    Py_DECREF(now);
+
+    now=toPyDateTime(clk::now());
+    cout << tostring(now) << endl;
+    Py_DECREF(now);
+
+
+    // Time series plot
+
+    // We have a time array (e.g. from a csv file):
+    size_t n=10;
+    vector<time_t> tvec;
+    time_t tstart=time(0);
+    for (size_t i=0; i<n; i++, tstart+=24*3600)
+	tvec.push_back(tstart);
+
+    // Create the python array of times - ONCE!
+    DateTimeList<time_t> tarray(tvec.data(), tvec.size());
+
+    // Create 2-column data and plot it against tarray:
+    vector<double> data(2*n);
+    for (size_t i=0; i<2*n; i++) data[i]=2.0*i+5;
+
+    plt::plot(tarray, data);
+    plt::xticks({{"rotation", "20"}});
+    plt::title("Linear");
+    plt::grid(true);
+    plt::show();
+
+    // Modify some data and plot again, reusing the time array:
+    for (size_t i=0; i<n; i++) data[i]=i*i-3.0;
+
+    // plt::plot((PyListObject*) tarray, data);
+    plt::plot(tarray, data);
+    plt::xticks({{"rotation", "20"}});
+    plt::title("Quadratic");
+    plt::grid(true);
+    plt::show();
+
+    // Unfortunately, we have to call the DateTimeList destructor explicitly
+    // for now, because the destructor needs an interpreter, which we kill
+    // on the next line. In turn, that's due to the singleton implementation
+    // of the interpreter using a static object.
+    //
+    // TODO: implement the singleton using a pointer. The pointer
+    // (to _interpreter::ctx) is still static, but ctx can be deleted at the
+    // right time (before Py_Finalize); it is not at the mercy of the OS.
+    tarray.~DateTimeList<time_t>();
+    plt::detail::_interpreter::kill();
+
+    return 0;
+}

matplotlibcpp.h

@@ -3,6 +3,7 @@
 // Python headers must be included before any system headers, since
 // they define _POSIX_C_SOURCE
 #include <Python.h>
+#include <datetime.h>
 
 #include <vector>
 #include <map>
@@ -11,11 +12,10 @@
 #include <algorithm>
 #include <stdexcept>
 #include <iostream>
-#include <cstdint> // <cstdint> requires c++11 support
 #include <functional>
-#include <string> // std::stod
-#include <span>
 #include <ranges>
+#include <chrono>
+#include <string>
 
 #ifndef WITHOUT_NUMPY
 #  define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
@@ -596,6 +596,7 @@ bool plot(const ContainerY& y, const std::map<std::string, std::string>& keyword
     return plot(x,y,keywords);
 }
 
+
 #else
 
 // For the less fortunate ones who can't or won't use C++ 20, we stick with
@@ -2307,6 +2308,27 @@ inline void xticks(const std::vector<Numeric> &ticks, const std::map<std::string
     xticks(ticks, {}, keywords);
 }
 
+// options only, e.g. plt::xticks(rotation=20)
+inline void xticks(const std::map<std::string, std::string>& keywords)
+{
+    detail::_interpreter::get();
+
+    PyObject* args = PyTuple_New(0);
+
+    // construct keyword args
+    PyObject* kwargs = PyDict_New();
+    for (const auto& [k, v] : keywords)
+        PyDict_SetItemString(kwargs, k.c_str(), PyString_FromString(v.c_str()));
+
+    PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_xticks, args, kwargs);
+
+    Py_DECREF(kwargs);
+    if(!res) throw std::runtime_error("Call to xticks() failed");
+
+    Py_DECREF(res);
+}
+
+
 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 = {})
 {
@@ -3227,4 +3249,7 @@ class Plot
     PyObject* set_data_fct = nullptr;
 };
 
+
 } // end namespace matplotlibcpp
+
+