jrpycpp 0.1.0__py3-none-any.whl

jrpycpp/examples/cpp_scripts/chapter6/demo/02-lambda.cpp

@@ -0,0 +1,22 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+int main() {
+    std::vector<double> values = {3.0, 1.0, 4.0, 1.0, 5.0, 9.0};
+
+    std::sort(values.begin(), values.end());
+    for (double v : values) {
+        std::cout << v << " ";
+    }
+    std::cout << "\n";
+
+    std::sort(values.begin(), values.end(), [](double a, double b) {
+        return a > b;
+    });
+    for (double v : values) {
+        std::cout << v << " ";
+    }
+    std::cout << "\n";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter6/demo/03-move.cpp

@@ -0,0 +1,14 @@
+#include <cstddef>
+#include <iostream>
+#include <utility>
+#include <vector>
+
+int main() {
+    std::vector<double> a(4, 1.0);
+    std::cout << "a has " << a.size() << " elements\n";
+
+    std::vector<double> b = std::move(a);
+    std::cout << "b has " << b.size() << " elements\n";
+    std::cout << "a now has " << a.size() << "\n";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter6/demo/04-unique.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+#include <memory>
+
+class Noisy {
+public:
+    Noisy() { std::cout << "made\n"; }
+    ~Noisy() { std::cout << "destroyed\n"; }
+    void speak() const { std::cout << "here\n"; }
+};
+
+int main() {
+    {
+        std::unique_ptr<Noisy> p = std::make_unique<Noisy>();
+        p->speak();
+        std::cout << "leaving the block\n";
+    }
+    std::cout << "after the block\n";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter6/exercise/copies.cpp

@@ -0,0 +1,34 @@
+#include <chrono>
+#include <cstddef>
+#include <iostream>
+#include <vector>
+
+std::vector<double> stage_one(std::vector<double> v) {
+    v[0] += 1.0;
+    return v;
+}
+
+std::vector<double> stage_two(std::vector<double> v) {
+    v[1] += 1.0;
+    return v;
+}
+
+std::vector<double> stage_three(std::vector<double> v) {
+    v[2] += 1.0;
+    return v;
+}
+
+int main() {
+    const std::size_t n = 10000000;
+    std::vector<double> values(n, 1.0);
+
+    auto start = std::chrono::steady_clock::now();
+
+    std::vector<double> result = stage_three(stage_two(stage_one(values)));
+
+    auto end = std::chrono::steady_clock::now();
+    double elapsed = std::chrono::duration<double>(end - start).count();
+
+    std::cout << "result[0] " << result[0] << ", took " << elapsed << " s\n";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter6/exercise/integrate.cpp

@@ -0,0 +1,20 @@
+#include <cmath>
+#include <iostream>
+
+double trapezium(double (*f)(double), double a, double b, int n) {
+    double h = (b - a) / n;
+    double total = 0.5 * (f(a) + f(b));
+    for (int i = 1; i < n; ++i) {
+        total += f(a + i * h);
+    }
+    return total * h;
+}
+
+double square(double x) {
+    return x * x;
+}
+
+int main() {
+    std::cout << "x squared from 0 to 1: " << trapezium(square, 0.0, 1.0, 1000) << "\n";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter6/exercise/words.cpp

@@ -0,0 +1,21 @@
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <string>
+
+int main() {
+    std::string text = "the cat sat on the mat the cat slept";
+    std::istringstream stream(text);
+
+    std::map<std::string, int> counts;
+    std::string word;
+
+    while (stream >> word) {
+        // Task 1: count this word
+    }
+
+    for (const auto& entry : counts) {
+        std::cout << entry.first << " " << entry.second << "\n";
+    }
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter6/solution/copies.cpp

@@ -0,0 +1,37 @@
+#include <chrono>
+#include <cstddef>
+#include <iostream>
+#include <utility>
+#include <vector>
+
+std::vector<double> stage_one(std::vector<double> v) {
+    v[0] += 1.0;
+    return v;
+}
+
+std::vector<double> stage_two(std::vector<double> v) {
+    v[1] += 1.0;
+    return v;
+}
+
+std::vector<double> stage_three(std::vector<double> v) {
+    v[2] += 1.0;
+    return v;
+}
+
+int main() {
+    const std::size_t n = 10000000;
+    std::vector<double> values(n, 1.0);
+
+    auto start = std::chrono::steady_clock::now();
+
+    std::vector<double> result =
+        stage_three(stage_two(stage_one(std::move(values))));
+
+    auto end = std::chrono::steady_clock::now();
+    double elapsed = std::chrono::duration<double>(end - start).count();
+
+    std::cout << "result[0] " << result[0] << ", took " << elapsed << " s\n";
+    std::cout << "values now has " << values.size() << " elements\n";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter6/solution/integrate.cpp

@@ -0,0 +1,25 @@
+#include <cmath>
+#include <functional>
+#include <iostream>
+
+double trapezium(const std::function<double(double)>& f, double a, double b, int n) {
+    double h = (b - a) / n;
+    double total = 0.5 * (f(a) + f(b));
+    for (int i = 1; i < n; ++i) {
+        total += f(a + i * h);
+    }
+    return total * h;
+}
+
+double square(double x) {
+    return x * x;
+}
+
+int main() {
+    std::cout << "x squared from 0 to 1: " << trapezium(square, 0.0, 1.0, 1000) << "\n";
+    std::cout << "x cubed from 0 to 1:   "
+              << trapezium([](double x) { return x * x * x; }, 0.0, 1.0, 1000) << "\n";
+    std::cout << "sine from 0 to pi:     "
+              << trapezium([](double x) { return std::sin(x); }, 0.0, M_PI, 1000) << "\n";
+    return 0;
+}

jrpycpp/examples/cpp_scripts/chapter6/solution/words.cpp

@@ -0,0 +1,21 @@
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <string>
+
+int main() {
+    std::string text = "the cat sat on the mat the cat slept";
+    std::istringstream stream(text);
+
+    std::map<std::string, int> counts;
+    std::string word;
+
+    while (stream >> word) {
+        counts[word] += 1;
+    }
+
+    for (const auto& entry : counts) {
+        std::cout << entry.first << " " << entry.second << "\n";
+    }
+    return 0;
+}

jrpycpp/examples/templates/cpp-project/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/templates/cpp-project/README.md

@@ -0,0 +1,68 @@
+# C++ project template
+
+A small C++ library with a program that uses it and tests that check it.
+Copy this directory, rename it, and start.
+
+## What is where
+
+```
+include/stats.h      the public header: what other code may use
+src/stats.cpp        the implementation
+src/main.cpp         a program that links the library
+tests/test_stats.cpp the tests
+CMakeLists.txt       how to build all of it
+```
+
+Nothing is built inside those directories. Everything CMake produces goes into
+a build directory you can delete.
+
+## Build, run, test
+
+    cmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    cmake --build build
+    ./build/report
+    ctest --test-dir build --output-on-failure
+
+The build type is not optional. With none, CMake passes no optimisation flags
+at all, and you will be measuring something you would never ship. Use
+`RelWithDebInfo` while developing and `Release` when you mean it. `Debug` when
+you are in a debugger.
+
+## Renaming it for your project
+
+Three places, and nothing else:
+
+1. `project(stats ...)` in `CMakeLists.txt`
+2. the library and target names, `stats`, `report`, `test_stats`
+3. the file names in `include/`, `src/` and `tests/`
+
+## Adding a library somebody else wrote
+
+Two lines. Eigen, for a matrix library, is the one most people want first:
+
+    find_package(Eigen3 3.4 REQUIRED)
+    target_link_libraries(stats PUBLIC Eigen3::Eigen)
+
+`find_package` looks for it where it is installed; nothing is copied into this
+repository. `PUBLIC` means anything linking your library gets Eigen's headers
+too, which is what you want if your public header mentions an Eigen type, and
+`PRIVATE` is right when it does not.
+
+Install it first with your package manager: `apt install libeigen3-dev`, or
+`brew install eigen`. Catch2, used by the tests here, is found the same way.
+
+## Adding a test
+
+Write another `TEST_CASE` in `tests/test_stats.cpp`, or another file added to
+`add_executable`. You do not need to register it anywhere:
+`catch_discover_tests` runs the binary at build time and asks it what tests it
+has.
+
+## Two Catch2 behaviours that surprise people
+
+Test order is randomised by default. A suite that passes in one order and fails
+in another has found a real dependency between its tests, which is worth
+knowing rather than hiding; `--order decl` restores declaration order.
+
+On failure Catch2 exits 42 and `ctest` exits 8. Both matter if you wire this
+into CI and neither before then.

jrpycpp/examples/templates/cpp-project/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/templates/cpp-project/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/templates/cpp-project/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/templates/cpp-project/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/templates/python-cpp-project/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/templates/python-cpp-project/README.md

@@ -0,0 +1,72 @@
+# Python and C++ project template
+
+One C++ library with two front doors: a C++ test suite, and a Python module
+built from the same sources. Copy the directory and rename it, as with the
+C++ template.
+
+## What is where
+
+```
+include/stats.h       the public header
+src/stats.cpp         the implementation
+python/bindings.cpp   the pybind11 layer: what Python sees
+tests/test_stats.cpp  C++ tests, for the library
+tests/test_livstats.py Python tests, for the module
+CMakeLists.txt        how to build all of it
+pyproject.toml        how pip builds the module
+```
+
+## Build and test the Python module
+
+    pip install --no-build-isolation .
+    python -c "import livstats; print(livstats.Stats([1.0, 2.0, 3.0]).mean())"
+    pytest tests/
+
+`pip install` runs CMake underneath, through scikit-build-core. There is no
+second build system.
+
+`--no-build-isolation` is worth understanding rather than copying. Without it,
+pip builds in a fresh environment and fetches its build dependencies from the
+network every time, even when your environment already has them. With it, pip
+uses what you have installed. On a machine with no network the flag is the
+difference between a build and an error.
+
+For a development loop, an editable install rebuilds only what changed:
+
+    pip install --no-build-isolation -e .
+
+## Build and test the C++ side
+
+    cmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo
+    cmake --build build
+    ctest --test-dir build --output-on-failure
+
+The C++ tests are wired only when CMake is invoked directly, not when pip
+drives it. That is the `if(NOT SKBUILD)` block: a wheel does not need a test
+binary in it.
+
+## What to test where
+
+The C++ tests own the mathematics. The Python tests own the boundary: that
+arguments convert, that return types arrive as real Python objects, that
+exceptions become the Python exceptions you meant. Re-testing the numerics
+through Python is slower, less precise, and debugs in the wrong language.
+
+## One line you must not delete
+
+    set_target_properties(stats PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+A static library linked into a shared Python module needs it. Without it the
+link fails and tells you to recompile with `-fPIC`.
+
+## Renaming it
+
+`project()` in `CMakeLists.txt`, the `name` in `pyproject.toml`, the target
+names, and the module name in `PYBIND11_MODULE(...)`. The module name in the
+C++ and the `install(TARGETS ...)` name must match, or `import` will not find
+it.
+
+## Adding a library somebody else wrote
+
+Same as the C++ template: `find_package`, then `target_link_libraries`. If the
+library appears in your public header, link it `PUBLIC`, otherwise `PRIVATE`.

jrpycpp/examples/templates/python-cpp-project/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/templates/python-cpp-project/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/templates/python-cpp-project/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/templates/python-cpp-project/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/templates/python-cpp-project/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/templates/python-cpp-project/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.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+from shutil import copytree, ignore_patterns
+
+
+def _populate(name, target_path):
+    """Copy one bundled examples folder into the user's working directory."""
+    source_dir = Path(__file__).parent / "examples" / name
+
+    destination = Path.cwd() / target_path / name
+
+    if destination.exists():
+        raise FileExistsError(
+            f"A folder named '{name}' already exists in the target "
+            "directory. Rename this or populate a different directory instead."
+        )
+
+    # Installing the package byte-compiles the example .py files, so skip the
+    # __pycache__ folders that leaves behind
+    copytree(
+        src=source_dir,
+        dst=destination,
+        ignore=ignore_patterns("__pycache__"),
+    )
+
+    print(f"Copied to: {destination.resolve()}")
+
+
+def populate_cpp_scripts(target_path=".."):
+    """Populate the C++ example scripts into the user's working directory.
+
+    The scripts are copied to the parent directory by default, so that they
+    sit alongside the notebooks rather than inside them.
+    """
+    _populate("cpp_scripts", target_path)
+
+
+def populate_templates(target_path=".."):
+    """Populate the two project templates into the user's working directory.
+
+    These are the templates attendees take away: a C++ library with tests,
+    and the same library behind a Python module.
+    """
+    _populate("templates", target_path)

jrpycpp-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: jrpycpp
+Version: 0.1.0
+Summary: Jumping Rivers: C++ and Python
+Author: Jumping Rivers
+Author-email: info@jumpingrivers.com
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: numpy (>=2.0,<3.0)
+Requires-Dist: pybind11 (>=3.0,<4.0)
+Requires-Dist: pytest (>=8.0,<9.0)
+Requires-Dist: scikit-build-core (>=0.11,<0.12)
+Requires-Dist: setuptools (>=64)