jrpycpp 0.1.0__py3-none-any.whl

jrpycpp/examples/cpp_scripts/chapter4/exercise/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/exercise/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/exercise/bindings.cpp

@@ -0,0 +1,36 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+
+#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;
+    }
+}
+
+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"), py::arg("factor"),
+          "Multiply an array of doubles in place");
+}

jrpycpp/examples/cpp_scripts/chapter4/exercise/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/exercise/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/solution/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/solution/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/solution/bindings.cpp

@@ -0,0 +1,49 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+
+#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;
+}
+
+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");
+}

jrpycpp/examples/cpp_scripts/chapter4/solution/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/solution/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/solution/test_arrays.py

@@ -0,0 +1,19 @@
+import numpy as np
+import pytest
+
+import livarrays
+
+
+def test_squares():
+    assert livarrays.squares(4) == pytest.approx(np.array([0.0, 1.0, 4.0, 9.0]))
+
+
+def test_noconvert_refuses_int32():
+    with pytest.raises(TypeError):
+        livarrays.scale_inplace(np.arange(5, dtype=np.int32), 2.0)
+
+
+def test_float64_is_changed_in_place():
+    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]))

jrpycpp/examples/cpp_scripts/chapter5/demo/01-cmake/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.16)
+project(stats LANGUAGES CXX VERSION 0.1.0)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+add_library(stats src/stats.cpp)
+target_include_directories(stats PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_compile_options(stats PRIVATE -Wall -Wextra)
+
+add_executable(report src/main.cpp)
+target_link_libraries(report PRIVATE stats)
+
+enable_testing()
+
+find_package(Catch2 3 REQUIRED)
+add_executable(test_stats tests/test_stats.cpp)
+target_link_libraries(test_stats PRIVATE stats Catch2::Catch2WithMain)
+
+include(Catch)
+catch_discover_tests(test_stats)

jrpycpp/examples/cpp_scripts/chapter5/demo/01-cmake/include/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/chapter5/demo/01-cmake/src/main.cpp

@@ -0,0 +1,9 @@
+#include <iostream>
+
+#include "stats.h"
+
+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";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter5/demo/01-cmake/src/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/chapter5/demo/01-cmake/tests/test_stats.cpp

@@ -0,0 +1,20 @@
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+
+#include "stats.h"
+
+using Catch::Approx;
+
+TEST_CASE("mean of yesterday's numbers", "[stats]") {
+    Stats s({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0});
+    REQUIRE(s.mean() == Approx(5.0));
+}
+
+TEST_CASE("standard deviation of yesterday's numbers", "[stats]") {
+    Stats s({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0});
+    REQUIRE(s.stddev() == Approx(2.0));
+}
+
+TEST_CASE("count is the number of values", "[stats]") {
+    REQUIRE(Stats({1.0, 2.0, 3.0}).count() == 3);
+}

jrpycpp/examples/cpp_scripts/chapter5/demo/02-python/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.16)
+project(livstats LANGUAGES CXX VERSION 0.1.0)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+add_library(stats src/stats.cpp)
+target_include_directories(stats PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_compile_options(stats PRIVATE -Wall -Wextra)
+set_target_properties(stats PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+set(PYBIND11_FINDPYTHON ON)
+find_package(pybind11 CONFIG REQUIRED)
+
+pybind11_add_module(livstats python/bindings.cpp)
+target_link_libraries(livstats PRIVATE stats)
+
+install(TARGETS livstats DESTINATION .)
+
+if(NOT SKBUILD)
+  enable_testing()
+  find_package(Catch2 3 REQUIRED)
+  add_executable(test_stats tests/test_stats.cpp)
+  target_link_libraries(test_stats PRIVATE stats Catch2::Catch2WithMain)
+  include(Catch)
+  catch_discover_tests(test_stats)
+endif()

jrpycpp/examples/cpp_scripts/chapter5/demo/02-python/include/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/chapter5/demo/02-python/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["scikit-build-core>=0.11", "pybind11>=3.0"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "livstats"
+version = "0.1.0"
+requires-python = ">=3.9"
+
+[tool.scikit-build]
+minimum-version = "build-system.requires"

jrpycpp/examples/cpp_scripts/chapter5/demo/02-python/python/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() = "The stats library, built by CMake";
+
+    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/chapter5/demo/02-python/src/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/chapter5/demo/02-python/tests/test_livstats.py

@@ -0,0 +1,10 @@
+import pytest
+
+import livstats
+
+
+def test_the_class_survived_the_move_to_cmake():
+    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

jrpycpp/examples/cpp_scripts/chapter5/demo/02-python/tests/test_stats.cpp

@@ -0,0 +1,20 @@
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+
+#include "stats.h"
+
+using Catch::Approx;
+
+TEST_CASE("mean of yesterday's numbers", "[stats]") {
+    Stats s({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0});
+    REQUIRE(s.mean() == Approx(5.0));
+}
+
+TEST_CASE("standard deviation of yesterday's numbers", "[stats]") {
+    Stats s({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0});
+    REQUIRE(s.stddev() == Approx(2.0));
+}
+
+TEST_CASE("count is the number of values", "[stats]") {
+    REQUIRE(Stats({1.0, 2.0, 3.0}).count() == 3);
+}

jrpycpp/examples/cpp_scripts/chapter5/exercise/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.16)
+project(stats LANGUAGES CXX VERSION 0.1.0)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+add_library(stats src/stats.cpp)
+target_include_directories(stats PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_compile_options(stats PRIVATE -Wall -Wextra)
+
+add_executable(report src/main.cpp)
+target_link_libraries(report PRIVATE stats)
+
+# Task 2 goes here: enable testing, find Catch2, build tests/test_stats.cpp
+# into a target that links stats and Catch2::Catch2WithMain, and register it
+# with catch_discover_tests.

jrpycpp/examples/cpp_scripts/chapter5/exercise/include/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/chapter5/exercise/src/main.cpp

@@ -0,0 +1,9 @@
+#include <iostream>
+
+#include "stats.h"
+
+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";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter5/exercise/src/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/chapter5/exercise/tests/test_stats.cpp

@@ -0,0 +1,16 @@
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+
+#include "stats.h"
+
+using Catch::Approx;
+
+TEST_CASE("mean of yesterday's numbers", "[stats]") {
+    Stats s({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0});
+    REQUIRE(s.mean() == Approx(5.0));
+}
+
+TEST_CASE("standard deviation of yesterday's numbers", "[stats]") {
+    Stats s({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0});
+    REQUIRE(s.stddev() == Approx(1.5));
+}

jrpycpp/examples/cpp_scripts/chapter5/solution/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.16)
+project(stats LANGUAGES CXX VERSION 0.1.0)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+add_library(stats src/stats.cpp)
+target_include_directories(stats PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_compile_options(stats PRIVATE -Wall -Wextra)
+
+add_executable(report src/main.cpp)
+target_link_libraries(report PRIVATE stats)
+
+enable_testing()
+
+find_package(Catch2 3 REQUIRED)
+add_executable(test_stats tests/test_stats.cpp)
+target_link_libraries(test_stats PRIVATE stats Catch2::Catch2WithMain)
+
+include(Catch)
+catch_discover_tests(test_stats)

jrpycpp/examples/cpp_scripts/chapter5/solution/include/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/chapter5/solution/src/main.cpp

@@ -0,0 +1,9 @@
+#include <iostream>
+
+#include "stats.h"
+
+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";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter5/solution/src/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/chapter5/solution/tests/test_stats.cpp

@@ -0,0 +1,20 @@
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+
+#include "stats.h"
+
+using Catch::Approx;
+
+TEST_CASE("mean of yesterday's numbers", "[stats]") {
+    Stats s({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0});
+    REQUIRE(s.mean() == Approx(5.0));
+}
+
+TEST_CASE("standard deviation of yesterday's numbers", "[stats]") {
+    Stats s({2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0});
+    REQUIRE(s.stddev() == Approx(2.0));
+}
+
+TEST_CASE("count is the number of values", "[stats]") {
+    REQUIRE(Stats({1.0, 2.0, 3.0}).count() == 3);
+}

jrpycpp/examples/cpp_scripts/chapter6/demo/01-map.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+#include <map>
+#include <string>
+
+int main() {
+    std::map<std::string, int> counts;
+
+    counts["alpha"] = 1;
+    counts["beta"] += 1;
+    counts["alpha"] += 1;
+
+    for (const auto& entry : counts) {
+        std::cout << entry.first << " " << entry.second << "\n";
+    }
+
+    std::cout << "beta present: " << (counts.count("beta") == 1) << "\n";
+    std::cout << "gamma present: " << (counts.count("gamma") == 1) << "\n";
+    return 0;
+}