jrpycpp 0.1.0__py3-none-any.whl

jrpycpp/__init__.py

@@ -0,0 +1,3 @@
+from .__version__ import __version__  # noqa: F401
+
+from . import examples  # noqa: F401

jrpycpp/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

jrpycpp/examples/cpp_scripts/chapter2/demo/01-class.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <vector>
+
+class Stats {
+public:
+    Stats(const std::vector<double>& values) : values_(values) {}
+
+    double mean() {
+        double total = 0.0;
+        for (double v : values_) {
+            total += v;
+        }
+        return total / values_.size();
+    }
+
+private:
+    std::vector<double> values_;
+};
+
+int main() {
+    Stats s({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0});
+    std::cout << "mean " << s.mean() << "\n";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter2/demo/02-const.cpp

@@ -0,0 +1,25 @@
+#include <iostream>
+#include <vector>
+
+class Stats {
+public:
+    Stats(const std::vector<double>& values) : values_(values) {}
+    double mean() const {
+        double total = 0.0;
+        for (double v : values_) {
+            total += v;
+        }
+        return total / values_.size();
+    }
+private:
+    std::vector<double> values_;
+};
+
+void report(const Stats& s) {
+    std::cout << "mean " << s.mean() << "\n";
+}
+
+int main() {
+    report(Stats({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0}));
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter2/exercise/stats.cpp

@@ -0,0 +1,26 @@
+#include <cmath>
+#include <iostream>
+#include <vector>
+
+double mean(const std::vector<double>& values) {
+    double total = 0.0;
+    for (double v : values) {
+        total += v;
+    }
+    return total / values.size();
+}
+
+double stddev(const std::vector<double>& values) {
+    double m = mean(values);
+    double total = 0.0;
+    for (double v : values) {
+        total += (v - m) * (v - m);
+    }
+    return std::sqrt(total / values.size());
+}
+
+int main() {
+    std::vector<double> values = {2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0};
+    std::cout << "mean " << mean(values) << ", standard deviation " << stddev(values) << "\n";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter2/solution/stats.cpp

@@ -0,0 +1,44 @@
+#include <cmath>
+#include <iostream>
+#include <vector>
+
+class Stats {
+public:
+    Stats(const std::vector<double>& values) : values_(values) {}
+
+    double mean() const {
+        double total = 0.0;
+        for (double v : values_) {
+            total += v;
+        }
+        return total / values_.size();
+    }
+
+    double stddev() const {
+        double m = mean();
+        double total = 0.0;
+        for (double v : values_) {
+            total += (v - m) * (v - m);
+        }
+        return std::sqrt(total / values_.size());
+    }
+
+    int count() const {
+        return static_cast<int>(values_.size());
+    }
+
+private:
+    std::vector<double> values_;
+};
+
+void report(const Stats& s) {
+    std::cout << "mean " << s.mean() << "\n";
+}
+
+int main() {
+    Stats s({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0});
+    std::cout << "mean " << s.mean() << ", standard deviation " << s.stddev() << "\n";
+    std::cout << "count " << s.count() << "\n";
+    report(s);
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter3/demo/01-free-function/bindings.cpp

@@ -0,0 +1,11 @@
+#include <pybind11/pybind11.h>
+
+#include "pi.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(pidemo, m) {
+    m.doc() = "Yesterday's pi loop, callable from Python";
+    m.def("estimate_pi", &estimate_pi, py::arg("n"),
+          "Estimate pi with n rectangles");
+}

jrpycpp/examples/cpp_scripts/chapter3/demo/01-free-function/pi.cpp

@@ -0,0 +1,10 @@
+#include "pi.h"
+
+double estimate_pi(int n) {
+    double total = 0.0;
+    for (int i = 0; i < n; ++i) {
+        double x = (i + 0.5) / n;
+        total += 4.0 / (1.0 + x * x);
+    }
+    return total / n;
+}

jrpycpp/examples/cpp_scripts/chapter3/demo/01-free-function/pi.h

@@ -0,0 +1,3 @@
+#pragma once
+
+double estimate_pi(int n);

jrpycpp/examples/cpp_scripts/chapter3/demo/01-free-function/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["setuptools>=64", "pybind11>=3.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pidemo"
+version = "0.1.0"
+requires-python = ">=3.9"
+
+[tool.setuptools]
+py-modules = []

jrpycpp/examples/cpp_scripts/chapter3/demo/01-free-function/setup.py

@@ -0,0 +1,12 @@
+from setuptools import setup
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+
+ext_modules = [
+    Pybind11Extension(
+        "pidemo",
+        ["bindings.cpp", "pi.cpp"],
+        cxx_std=17,
+    ),
+]
+
+setup(ext_modules=ext_modules, cmdclass={"build_ext": build_ext})

jrpycpp/examples/cpp_scripts/chapter3/demo/01-free-function/test_pi.py

@@ -0,0 +1,11 @@
+import math
+
+import pidemo
+
+
+def test_estimate_pi_converges():
+    assert abs(pidemo.estimate_pi(1000000) - math.pi) < 1e-6
+
+
+def test_estimate_pi_is_documented():
+    assert "Estimate pi" in pidemo.estimate_pi.__doc__

jrpycpp/examples/cpp_scripts/chapter3/demo/02-class/bindings.cpp

@@ -0,0 +1,17 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "stats.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(livstats, m) {
+    m.doc() = "Yesterday's stats program, callable from Python";
+
+    py::class_<Stats>(m, "Stats")
+        .def(py::init<const std::vector<double>&>(), py::arg("values"),
+             "Build from a sequence of numbers")
+        .def("mean", &Stats::mean, "Arithmetic mean")
+        .def("stddev", &Stats::stddev, "Standard deviation, dividing by n")
+        .def("count", &Stats::count, "How many values");
+}

jrpycpp/examples/cpp_scripts/chapter3/demo/02-class/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["setuptools>=64", "pybind11>=3.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "livstats"
+version = "0.1.0"
+requires-python = ">=3.9"
+
+[tool.setuptools]
+py-modules = []

jrpycpp/examples/cpp_scripts/chapter3/demo/02-class/setup.py

@@ -0,0 +1,12 @@
+from setuptools import setup
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+
+ext_modules = [
+    Pybind11Extension(
+        "livstats",
+        ["bindings.cpp", "stats.cpp"],
+        cxx_std=17,
+    ),
+]
+
+setup(ext_modules=ext_modules, cmdclass={"build_ext": build_ext})

jrpycpp/examples/cpp_scripts/chapter3/demo/02-class/stats.cpp

@@ -0,0 +1,26 @@
+#include "stats.h"
+
+#include <cmath>
+
+Stats::Stats(const std::vector<double>& values) : values_(values) {}
+
+double Stats::mean() const {
+    double total = 0.0;
+    for (double v : values_) {
+        total += v;
+    }
+    return total / values_.size();
+}
+
+double Stats::stddev() const {
+    double m = mean();
+    double total = 0.0;
+    for (double v : values_) {
+        total += (v - m) * (v - m);
+    }
+    return std::sqrt(total / values_.size());
+}
+
+int Stats::count() const {
+    return static_cast<int>(values_.size());
+}

jrpycpp/examples/cpp_scripts/chapter3/demo/02-class/stats.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <vector>
+
+class Stats {
+public:
+    Stats(const std::vector<double>& values);
+
+    double mean() const;
+    double stddev() const;
+    int count() const;
+
+private:
+    std::vector<double> values_;
+};

jrpycpp/examples/cpp_scripts/chapter3/demo/02-class/test_livstats.py

@@ -0,0 +1,18 @@
+import pytest
+
+import livstats
+
+
+def test_the_chapter_one_promise():
+    s = livstats.Stats([2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0])
+    assert s.mean() == pytest.approx(5.0)
+    assert s.stddev() == pytest.approx(2.0)
+    assert s.count() == 8
+
+
+def test_a_list_of_ints_is_accepted():
+    assert livstats.Stats([1, 2, 3]).mean() == pytest.approx(2.0)
+
+
+def test_the_constructor_takes_a_named_argument():
+    assert livstats.Stats(values=[1.0, 3.0]).mean() == pytest.approx(2.0)

jrpycpp/examples/cpp_scripts/chapter3/exercise/bindings.cpp

@@ -0,0 +1,12 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "stats.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(livstats, m) {
+    py::class_<Stats>(m, "Stats")
+        .def(py::init<const std::vector<double>&>(), py::arg("values"))
+        .def("mean", &Stats::mean);
+}

jrpycpp/examples/cpp_scripts/chapter3/exercise/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["setuptools>=64", "pybind11>=3.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "livstats"
+version = "0.1.0"
+requires-python = ">=3.9"
+
+[tool.setuptools]
+py-modules = []

jrpycpp/examples/cpp_scripts/chapter3/exercise/setup.py

@@ -0,0 +1,12 @@
+from setuptools import setup
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+
+ext_modules = [
+    Pybind11Extension(
+        "livstats",
+        ["bindings.cpp", "stats.cpp"],
+        cxx_std=17,
+    ),
+]
+
+setup(ext_modules=ext_modules, cmdclass={"build_ext": build_ext})

jrpycpp/examples/cpp_scripts/chapter3/exercise/stats.cpp

@@ -0,0 +1,26 @@
+#include "stats.h"
+
+#include <cmath>
+
+Stats::Stats(const std::vector<double>& values) : values_(values) {}
+
+double Stats::mean() const {
+    double total = 0.0;
+    for (double v : values_) {
+        total += v;
+    }
+    return total / values_.size();
+}
+
+double Stats::stddev() const {
+    double m = mean();
+    double total = 0.0;
+    for (double v : values_) {
+        total += (v - m) * (v - m);
+    }
+    return std::sqrt(total / values_.size());
+}
+
+int Stats::count() const {
+    return static_cast<int>(values_.size());
+}

jrpycpp/examples/cpp_scripts/chapter3/exercise/stats.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <vector>
+
+class Stats {
+public:
+    Stats(const std::vector<double>& values);
+
+    double mean() const;
+    double stddev() const;
+    int count() const;
+
+private:
+    std::vector<double> values_;
+};

jrpycpp/examples/cpp_scripts/chapter3/solution/bindings.cpp

@@ -0,0 +1,22 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <string>
+
+#include "stats.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(livstats, m) {
+    m.doc() = "Yesterday's stats program, callable from Python";
+
+    py::class_<Stats>(m, "Stats")
+        .def(py::init<const std::vector<double>&>(), py::arg("values"),
+             "Build from a sequence of numbers")
+        .def("mean", &Stats::mean, "Arithmetic mean")
+        .def("stddev", &Stats::stddev, "Standard deviation, dividing by n")
+        .def("count", &Stats::count, "How many values")
+        .def("__repr__", [](const Stats& s) {
+            return "Stats(count=" + std::to_string(s.count()) + ")";
+        });
+}

jrpycpp/examples/cpp_scripts/chapter3/solution/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["setuptools>=64", "pybind11>=3.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "livstats"
+version = "0.1.0"
+requires-python = ">=3.9"
+
+[tool.setuptools]
+py-modules = []

jrpycpp/examples/cpp_scripts/chapter3/solution/setup.py

@@ -0,0 +1,12 @@
+from setuptools import setup
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+
+ext_modules = [
+    Pybind11Extension(
+        "livstats",
+        ["bindings.cpp", "stats.cpp"],
+        cxx_std=17,
+    ),
+]
+
+setup(ext_modules=ext_modules, cmdclass={"build_ext": build_ext})

jrpycpp/examples/cpp_scripts/chapter3/solution/stats.cpp

@@ -0,0 +1,26 @@
+#include "stats.h"
+
+#include <cmath>
+
+Stats::Stats(const std::vector<double>& values) : values_(values) {}
+
+double Stats::mean() const {
+    double total = 0.0;
+    for (double v : values_) {
+        total += v;
+    }
+    return total / values_.size();
+}
+
+double Stats::stddev() const {
+    double m = mean();
+    double total = 0.0;
+    for (double v : values_) {
+        total += (v - m) * (v - m);
+    }
+    return std::sqrt(total / values_.size());
+}
+
+int Stats::count() const {
+    return static_cast<int>(values_.size());
+}

jrpycpp/examples/cpp_scripts/chapter3/solution/stats.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <vector>
+
+class Stats {
+public:
+    Stats(const std::vector<double>& values);
+
+    double mean() const;
+    double stddev() const;
+    int count() const;
+
+private:
+    std::vector<double> values_;
+};

jrpycpp/examples/cpp_scripts/chapter3/solution/test_livstats.py

@@ -0,0 +1,18 @@
+import pytest
+
+import livstats
+
+
+def test_all_three_are_bound():
+    s = livstats.Stats([2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0])
+    assert s.mean() == pytest.approx(5.0)
+    assert s.stddev() == pytest.approx(2.0)
+    assert s.count() == 8
+
+
+def test_repr_says_what_it_holds():
+    assert repr(livstats.Stats([1.0, 2.0, 3.0])) == "Stats(count=3)"
+
+
+def test_the_docstrings_arrived():
+    assert "Arithmetic mean" in livstats.Stats.mean.__doc__

jrpycpp/examples/cpp_scripts/chapter4/demo/arrays.cpp

@@ -0,0 +1,13 @@
+#include "arrays.h"
+
+double total(const double* data, std::size_t n) {
+    double sum = 0.0;
+    for (std::size_t i = 0; i < n; ++i) {
+        sum += data[i];
+    }
+    return sum;
+}
+
+double total_vector(const std::vector<double>& v) {
+    return total(v.data(), v.size());
+}

jrpycpp/examples/cpp_scripts/chapter4/demo/arrays.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <cstddef>
+#include <vector>
+
+double total(const double* data, std::size_t n);
+double total_vector(const std::vector<double>& v);

jrpycpp/examples/cpp_scripts/chapter4/demo/bindings.cpp

@@ -0,0 +1,73 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+
+#include <vector>
+
+#include "arrays.h"
+
+namespace py = pybind11;
+
+double total_array(py::array_t<double> values) {
+    auto v = values.unchecked<1>();
+    double sum = 0.0;
+    for (py::ssize_t i = 0; i < v.shape(0); ++i) {
+        sum += v(i);
+    }
+    return sum;
+}
+
+void scale_inplace(py::array_t<double> values, double factor) {
+    auto v = values.mutable_unchecked<1>();
+    for (py::ssize_t i = 0; i < v.shape(0); ++i) {
+        v(i) *= factor;
+    }
+}
+
+py::array_t<double> squares(py::ssize_t n) {
+    py::array_t<double> out(n);
+    auto o = out.mutable_unchecked<1>();
+    for (py::ssize_t i = 0; i < n; ++i) {
+        o(i) = static_cast<double>(i) * static_cast<double>(i);
+    }
+    return out;
+}
+
+class Grid {
+public:
+    Grid(py::ssize_t n) : values_(static_cast<std::size_t>(n), 1.0) {}
+
+    py::ssize_t size() const { return static_cast<py::ssize_t>(values_.size()); }
+    double* data() { return values_.data(); }
+    void grow() { values_.push_back(1.0); }
+
+private:
+    std::vector<double> values_;
+};
+
+PYBIND11_MODULE(livarrays, m) {
+    m.doc() = "NumPy arrays crossing into C++";
+
+    m.def("total_array", &total_array, py::arg("values"),
+          "Sum an array of doubles without copying it");
+
+    m.def("total_list", &total_vector, py::arg("values"),
+          "Sum a sequence, copying it into a vector first");
+
+    m.def("scale_inplace", &scale_inplace,
+          py::arg("values").noconvert(), py::arg("factor"),
+          "Multiply an array of doubles in place");
+
+    m.def("squares", &squares, py::arg("n"),
+          "Return the first n squares as a new array");
+
+    py::class_<Grid>(m, "Grid")
+        .def(py::init<py::ssize_t>(), py::arg("n"))
+        .def("grow", &Grid::grow, "Append one element")
+        .def("view", [](py::object self) {
+            Grid& g = self.cast<Grid&>();
+            return py::array_t<double>({g.size()},
+                                       {static_cast<py::ssize_t>(sizeof(double))},
+                                       g.data(), self);
+        }, "A NumPy view onto this Grid's own memory");
+}

jrpycpp/examples/cpp_scripts/chapter4/demo/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["setuptools>=64", "pybind11>=3.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "livarrays"
+version = "0.1.0"
+requires-python = ">=3.9"
+
+[tool.setuptools]
+py-modules = []

jrpycpp/examples/cpp_scripts/chapter4/demo/setup.py

@@ -0,0 +1,12 @@
+from setuptools import setup
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+
+ext_modules = [
+    Pybind11Extension(
+        "livarrays",
+        ["bindings.cpp", "arrays.cpp"],
+        cxx_std=17,
+    ),
+]
+
+setup(ext_modules=ext_modules, cmdclass={"build_ext": build_ext})

jrpycpp/examples/cpp_scripts/chapter4/demo/test_arrays.py

@@ -0,0 +1,38 @@
+import numpy as np
+import pytest
+
+import livarrays
+
+
+def test_total_reads_a_strided_view_correctly():
+    assert livarrays.total_array(np.arange(10.0)[::2]) == pytest.approx(20.0)
+
+
+def test_total_list_goes_through_the_cpp_pointer_function():
+    assert livarrays.total_list([1.0, 2.0, 3.0]) == pytest.approx(6.0)
+
+
+def test_scale_inplace_changes_the_callers_array():
+    a = np.arange(5.0)
+    livarrays.scale_inplace(a, 2.0)
+    assert a == pytest.approx(np.array([0.0, 2.0, 4.0, 6.0, 8.0]))
+
+
+def test_noconvert_refuses_the_wrong_dtype():
+    with pytest.raises(TypeError):
+        livarrays.scale_inplace(np.arange(5, dtype=np.int32), 2.0)
+
+
+def test_squares_owns_its_data():
+    out = livarrays.squares(4)
+    assert out == pytest.approx(np.array([0.0, 1.0, 4.0, 9.0]))
+    assert out.flags.owndata is True
+
+
+def test_a_view_does_not_own_its_data_and_keeps_the_grid_alive():
+    g = livarrays.Grid(4)
+    v = g.view()
+    assert v.flags.owndata is False
+    assert v.base is g
+    v[0] = 7.0
+    assert g.view()[0] == pytest.approx(7.0)