sleipnirgroup-jormungandr 0.6.7.dev60__tar.gz → 0.6.7.dev62__tar.gz

{sleipnirgroup_jormungandr-0.6.7.dev60 → sleipnirgroup_jormungandr-0.6.7.dev62}/CMakeLists.txt

@@ -345,6 +345,19 @@ if(SLEIPNIR_BUILD_PYTHON)
         LIBRARY DESTINATION ${PY_DEST}
     )
 
+    # py-build-cmake copies the pure Python sources into the wheel itself.
+    # Install them for plain CMake installs as well.
+    if(NOT DEFINED PY_BUILD_CMAKE_MODULE_NAME)
+        install(
+            DIRECTORY python/src/sleipnir/
+            DESTINATION ${PY_DEST}
+            COMPONENT python_modules
+            FILES_MATCHING
+            PATTERN "*.py"
+            PATTERN "__pycache__" EXCLUDE
+        )
+    endif()
+
     # Generate stubs at install time because only the install tree has the
     # sleipnir/ package layout needed to import the module by its fully
     # qualified name `sleipnir._sleipnir`.

{sleipnirgroup_jormungandr-0.6.7.dev60 → sleipnirgroup_jormungandr-0.6.7.dev62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sleipnirgroup-jormungandr
-Version: 0.6.7.dev60
+Version: 0.6.7.dev62
 Summary: Reverse mode autodiff library and NLP solver DSL
 License-Expression: BSD-3-Clause
 License-File: LICENSE.txt

{sleipnirgroup_jormungandr-0.6.7.dev60 → sleipnirgroup_jormungandr-0.6.7.dev62}/pyproject.toml

@@ -88,9 +88,11 @@ cache-keys = [
     { file = "include/**" },
     { file = "pyproject.toml" },
     { file = "python/cpp/**/*.cpp" },
+    { file = "python/cpp/arity.hpp" },
     { file = "python/cpp/binders.hpp" },
     { file = "python/cpp/for_each_type.hpp" },
     { file = "python/cpp/slice_tuple.hpp" },
+    { file = "python/cpp/text_wrap.hpp" },
     { file = "python/cpp/try_cast.hpp" },
     { file = "python/src/**" },
     { file = "src/**" },

sleipnirgroup_jormungandr-0.6.7.dev62/python/cpp/arity.hpp

@@ -0,0 +1,42 @@
+// Copyright (c) Sleipnir contributors
+
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+
+namespace slp {
+
+/// Type implicitly convertible to any type. Used for counting aggregate
+/// members.
+struct AnyType {
+  template <typename T>
+  // NOLINTNEXTLINE (google-explicit-constructor)
+  operator T() const;
+};
+
+/// Returns the number of members in aggregate type T.
+///
+/// @tparam T Aggregate type.
+/// @tparam Args Initializers for the members counted so far.
+template <typename T, typename... Args>
+  requires std::is_aggregate_v<T>
+consteval size_t member_count() {
+  if constexpr (requires { T{Args{}..., AnyType{}}; }) {
+    return member_count<T, Args..., AnyType>();
+  } else {
+    return sizeof...(Args);
+  }
+}
+
+/// Returns the number of parameters of a lambda.
+///
+/// @tparam F Lambda type.
+template <typename F>
+consteval size_t lambda_param_count() {
+  return []<typename R, typename C, typename... Args>(R (C::*)(Args...) const) {
+    return sizeof...(Args);
+  }(&F::operator());
+}
+
+}  // namespace slp

sleipnirgroup_jormungandr-0.6.7.dev62/python/cpp/optimization/bind_problem.cpp

@@ -0,0 +1,216 @@
+// Copyright (c) Sleipnir contributors
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/function.h>
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <cstddef>
+#include <functional>
+#include <ranges>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <utility>
+
+#include <sleipnir/autodiff/variable.hpp>
+#include <sleipnir/autodiff/variable_matrix.hpp>
+#include <sleipnir/optimization/problem.hpp>
+#include <sleipnir/optimization/solver/iteration_info.hpp>
+#include <sleipnir/optimization/solver/options.hpp>
+
+#include "arity.hpp"
+#include "docstrings.hpp"
+#include "for_each_type.hpp"
+#include "text_wrap.hpp"
+
+namespace nb = nanobind;
+
+namespace slp {
+
+namespace {
+
+/// Name and docs of an Options member.
+struct OptionDoc {
+  /// Member name, which is also the solve() binding's keyword argument name.
+  const char* name;
+
+  /// Member docs.
+  const char* doc;
+};
+
+/// Name and docs of each Options member in declaration order.
+///
+/// See include/sleipnir/optimization/solver/options.hpp.
+constexpr OptionDoc option_docs[] = {
+    {"tolerance", DOC(slp, Options, tolerance)},
+    {"max_iterations", DOC(slp, Options, max_iterations)},
+    {"timeout", DOC(slp, Options, timeout)},
+    {"feasible_ipm", DOC(slp, Options, feasible_ipm)},
+    {"diagnostics", DOC(slp, Options, diagnostics)}};
+static_assert(member_count<Options>() == std::size(option_docs),
+              "Every Options member must be documented here and be a "
+              "keyword argument of the solve() binding");
+
+/// Returns the Python docstring for Problem.solve().
+///
+/// C++'s Problem<double>::solve() takes an Options object instead of keyword
+/// arguments, so its generated docstring documents a single `options` argument.
+/// This replaces that entry with the docs for each Options member.
+consteval const char* solve_doc() {
+  static constexpr auto doc = [] {
+    constexpr auto make_doc = [] {
+      std::string args;
+      for (const auto& [name, option_doc] : option_docs) {
+        // The Options member docs were wrapped without the "    name: " prefix,
+        // so they need to be rewrapped. pybind11_mkdoc's default docstring
+        // width is 70.
+        args += wrap(std::string{"    "} + std::string{name} + ": ", option_doc,
+                     70);
+        args += '\n';
+      }
+
+      // Find the start of the `options` entry
+      std::string result = DOC(slp, Problem, solve);
+      constexpr std::string_view options_entry = "    options: ";
+      auto begin = result.find(options_entry);
+      if (begin == std::string::npos) {
+        throw std::logic_error{
+            "Problem::solve() docs have no options argument"};
+      }
+
+      // Find the end of the `options` entry's last line. Each following line
+      // indented past the argument names is a continuation of the entry, as are
+      // any blank lines before it.
+      std::string_view rest = std::string_view{result}.substr(begin);
+      auto lines = rest | std::views::split('\n');
+      auto entry_end = std::ranges::end(lines.front());
+      for (auto line :
+           lines | std::views::drop(1) | std::views::take_while([](auto line) {
+             return line.empty() || std::string_view{line}.starts_with("     ");
+           })) {
+        if (!line.empty()) {
+          entry_end = line.end();
+        }
+      }
+
+      // Include the entry's trailing newline if it has one
+      size_t end = entry_end - rest.begin();
+      if (entry_end != rest.end()) {
+        ++end;
+      }
+
+      // Replace the `options` entry with the Options member entries
+      result.replace(begin, end, args);
+
+      return result;
+    };
+
+    std::array<char, make_doc().size() + 1> doc;
+    std::ranges::copy(make_doc(), doc.begin());
+    doc.back() = '\0';
+    return doc;
+  }();
+
+  return doc.data();
+}
+
+}  // namespace
+
+void bind_problem(nb::class_<Problem<double>>& cls) {
+  using namespace nb::literals;
+
+  cls.def(
+      "__init__",
+      [](Problem<double>* self) {
+        new (self) Problem<double>();
+
+        // Make Python signals (e.g., SIGINT from Ctrl-C) abort the solve
+        self->add_persistent_callback([](const IterationInfo<double>&) -> bool {
+          if (PyErr_CheckSignals() != 0) {
+            throw nb::python_error();
+          }
+          return false;
+        });
+      },
+      DOC(slp, Problem, Problem));
+  cls.def("decision_variable",
+          nb::overload_cast<>(&Problem<double>::decision_variable),
+          DOC(slp, Problem, decision_variable));
+  cls.def("decision_variable",
+          nb::overload_cast<int, int>(&Problem<double>::decision_variable),
+          "rows"_a, "cols"_a = 1, DOC(slp, Problem, decision_variable, 2));
+  cls.def("symmetric_decision_variable",
+          &Problem<double>::symmetric_decision_variable, "rows"_a,
+          DOC(slp, Problem, symmetric_decision_variable));
+  for_each_type<double, const Variable<double>&, const VariableMatrix<double>&>(
+      [&]<typename T> {
+        cls.def(
+            "minimize",
+            [](Problem<double>& self, T cost) { self.minimize(cost); },
+            "cost"_a, DOC(slp, Problem, minimize));
+        cls.def(
+            "maximize",
+            [](Problem<double>& self, T objective) {
+              self.maximize(objective);
+            },
+            "objective"_a, DOC(slp, Problem, maximize));
+      });
+  cls.def("subject_to",
+          nb::overload_cast<const EqualityConstraints<double>&>(
+              &Problem<double>::subject_to),
+          "constraint"_a, DOC(slp, Problem, subject_to));
+  cls.def("subject_to",
+          nb::overload_cast<const InequalityConstraints<double>&>(
+              &Problem<double>::subject_to),
+          "constraint"_a, DOC(slp, Problem, subject_to, 3));
+  cls.def("cost_function_type", &Problem<double>::cost_function_type,
+          DOC(slp, Problem, cost_function_type));
+  cls.def("equality_constraint_type",
+          &Problem<double>::equality_constraint_type,
+          DOC(slp, Problem, equality_constraint_type));
+  cls.def("inequality_constraint_type",
+          &Problem<double>::inequality_constraint_type,
+          DOC(slp, Problem, inequality_constraint_type));
+
+  // Maps Python's Problem.solve(**kwargs) to
+  // C++'s Problem::solve(Options, bool)
+  constexpr auto solve = [](Problem<double>& self, double tolerance,
+                            int max_iterations, double timeout,
+                            bool feasible_ipm, bool diagnostics, bool spy) {
+    return self.solve({.tolerance = tolerance,
+                       .max_iterations = max_iterations,
+                       .timeout = std::chrono::duration<double>{timeout},
+                       .feasible_ipm = feasible_ipm,
+                       .diagnostics = diagnostics},
+                      spy);
+  };
+  static_assert(
+      lambda_param_count<decltype(solve)>() == 1 + member_count<Options>() + 1,
+      "Every Options member must be a keyword argument of the solve() binding");
+
+  cls.def("solve", solve, nb::kw_only(),
+          nb::arg(option_docs[0].name) = Options{}.tolerance,
+          nb::arg(option_docs[1].name) = Options{}.max_iterations,
+          // nanobind renders defaults in signatures and stubs via repr(), and
+          // repr(float("inf")) is "inf", which isn't valid Python. Override the
+          // displayed default with sig().
+          nb::arg(option_docs[2].name).sig("float('inf')") =
+              Options{}.timeout.count(),
+          nb::arg(option_docs[3].name) = Options{}.feasible_ipm,
+          nb::arg(option_docs[4].name) = Options{}.diagnostics, "spy"_a = false,
+          solve_doc());
+
+  cls.def(
+      "add_callback",
+      [](Problem<double>& self,
+         std::function<bool(const IterationInfo<double>& info)> callback) {
+        self.add_callback(std::move(callback));
+      },
+      "callback"_a, DOC(slp, Problem, add_callback, 2));
+  cls.def("clear_callbacks", &Problem<double>::clear_callbacks,
+          DOC(slp, Problem, clear_callbacks));
+}
+
+}  // namespace slp

sleipnirgroup_jormungandr-0.6.7.dev62/python/cpp/text_wrap.hpp

@@ -0,0 +1,84 @@
+// Copyright (c) Sleipnir contributors
+
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <string>
+#include <string_view>
+
+namespace slp {
+
+/// Returns the number of columns a UTF-8 string occupies.
+///
+/// @param text UTF-8 string.
+constexpr size_t display_width(std::string_view text) {
+  // Count bytes that aren't continuation bytes, since each code point has
+  // exactly one. We assume a code point is one column wide. See
+  // https://www.rfc-editor.org/rfc/rfc3629#section-3.
+  //
+  // A continuation byte's top two bits are 0b10, so keep only those bits and
+  // count the bytes where they're something else.
+  return static_cast<size_t>(std::ranges::count_if(
+      text, [](char c) { return (c & 0b11000000) != 0b10000000; }));
+}
+
+/// Word wraps text to the given width.
+///
+/// Paragraphs are separated by blank lines, and the line breaks within each
+/// paragraph are replaced. Continuation lines are indented by the prefix's
+/// width so they align with the text after the prefix, like a Google-style
+/// docstring argument entry. Words longer than the width aren't split.
+///
+/// @param prefix String placed before the first line.
+/// @param text UTF-8 text to wrap.
+/// @param width Maximum line width in columns, including the indentation.
+/// @return Wrapped text without a trailing newline.
+constexpr std::string wrap(std::string_view prefix, std::string_view text,
+                           size_t width) {
+  constexpr std::string_view whitespace = " \n";
+  const size_t indent = display_width(prefix);
+
+  std::string wrapped{prefix};
+  size_t column = indent;
+
+  // Greedily fill lines. Append each word to the current line if it fits, or
+  // start a new line indented to align with the text after the prefix.
+  size_t end = 0;
+  for (size_t begin = text.find_first_not_of(whitespace);
+       begin != std::string_view::npos;
+       begin = text.find_first_not_of(whitespace, end)) {
+    // Find the whitespace since the previous word
+    std::string_view gap = text.substr(end, begin - end);
+
+    // Find the current word
+    end = std::min(text.find_first_of(whitespace, begin), text.size());
+    std::string_view word = text.substr(begin, end - begin);
+    const size_t word_width = display_width(word);
+
+    if (wrapped.size() == prefix.size()) {
+      // Put the first word right after the prefix without a leading space
+    } else if (gap.contains("\n\n")) {
+      // Separate paragraphs with a blank line
+      wrapped += "\n\n";
+      wrapped.append(indent, ' ');
+      column = indent;
+    } else if (column + 1 + word_width > width) {
+      // The space and word would overflow, so put the word on the next line
+      wrapped += '\n';
+      wrapped.append(indent, ' ');
+      column = indent;
+    } else {
+      // The space and word fit, so put the word on the current line
+      wrapped += ' ';
+      ++column;
+    }
+
+    wrapped += word;
+    column += word_width;
+  }
+
+  return wrapped;
+}
+
+}  // namespace slp

{sleipnirgroup_jormungandr-0.6.7.dev60 → sleipnirgroup_jormungandr-0.6.7.dev62}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.7.dev60"
+__version__ = "0.6.7.dev62"

sleipnirgroup_jormungandr-0.6.7.dev60/python/cpp/optimization/bind_problem.cpp

@@ -1,156 +0,0 @@
-// Copyright (c) Sleipnir contributors
-
-#include <nanobind/nanobind.h>
-#include <nanobind/stl/function.h>
-
-#include <chrono>
-#include <format>
-#include <functional>
-#include <string>
-#include <utility>
-
-#include <sleipnir/autodiff/variable.hpp>
-#include <sleipnir/autodiff/variable_matrix.hpp>
-#include <sleipnir/optimization/problem.hpp>
-#include <sleipnir/optimization/solver/iteration_info.hpp>
-#include <sleipnir/optimization/solver/options.hpp>
-
-#include "docstrings.hpp"
-#include "for_each_type.hpp"
-
-namespace nb = nanobind;
-
-namespace slp {
-
-void bind_problem(nb::class_<Problem<double>>& cls) {
-  using namespace nb::literals;
-
-  cls.def(
-      "__init__",
-      [](Problem<double>* self) {
-        new (self) Problem<double>();
-
-        // Make Python signals (e.g., SIGINT from Ctrl-C) abort the solve
-        self->add_persistent_callback([](const IterationInfo<double>&) -> bool {
-          if (PyErr_CheckSignals() != 0) {
-            throw nb::python_error();
-          }
-          return false;
-        });
-      },
-      DOC(slp, Problem, Problem));
-  cls.def("decision_variable",
-          nb::overload_cast<>(&Problem<double>::decision_variable),
-          DOC(slp, Problem, decision_variable));
-  cls.def("decision_variable",
-          nb::overload_cast<int, int>(&Problem<double>::decision_variable),
-          "rows"_a, "cols"_a = 1, DOC(slp, Problem, decision_variable, 2));
-  cls.def("symmetric_decision_variable",
-          &Problem<double>::symmetric_decision_variable, "rows"_a,
-          DOC(slp, Problem, symmetric_decision_variable));
-  for_each_type<double, const Variable<double>&, const VariableMatrix<double>&>(
-      [&]<typename T> {
-        cls.def(
-            "minimize",
-            [](Problem<double>& self, T cost) { self.minimize(cost); },
-            "cost"_a, DOC(slp, Problem, minimize));
-        cls.def(
-            "maximize",
-            [](Problem<double>& self, T objective) {
-              self.maximize(objective);
-            },
-            "objective"_a, DOC(slp, Problem, maximize));
-      });
-  cls.def("subject_to",
-          nb::overload_cast<const EqualityConstraints<double>&>(
-              &Problem<double>::subject_to),
-          "constraint"_a, DOC(slp, Problem, subject_to));
-  cls.def("subject_to",
-          nb::overload_cast<const InequalityConstraints<double>&>(
-              &Problem<double>::subject_to),
-          "constraint"_a, DOC(slp, Problem, subject_to, 3));
-  cls.def("cost_function_type", &Problem<double>::cost_function_type,
-          DOC(slp, Problem, cost_function_type));
-  cls.def("equality_constraint_type",
-          &Problem<double>::equality_constraint_type,
-          DOC(slp, Problem, equality_constraint_type));
-  cls.def("inequality_constraint_type",
-          &Problem<double>::inequality_constraint_type,
-          DOC(slp, Problem, inequality_constraint_type));
-  cls.def(
-      "solve",
-      [](Problem<double>& self, const nb::kwargs& kwargs) {
-        Options options;
-        bool spy = false;
-
-        for (auto [key, value] : kwargs) {
-          // XXX: The keyword arguments are manually copied from the struct
-          // members in include/sleipnir/optimization/solver/options.hpp.
-          //
-          // C++'s Problem<double>::solve() takes an Options object instead of
-          // keyword arguments, so there's no compile-time checking that the
-          // arguments match.
-          auto key_str = nb::cast<std::string>(key);
-          if (key_str == "tolerance") {
-            options.tolerance = nb::cast<double>(value);
-          } else if (key_str == "max_iterations") {
-            options.max_iterations = nb::cast<int>(value);
-          } else if (key_str == "timeout") {
-            options.timeout =
-                std::chrono::duration<double>{nb::cast<double>(value)};
-          } else if (key_str == "feasible_ipm") {
-            options.feasible_ipm = nb::cast<bool>(value);
-          } else if (key_str == "diagnostics") {
-            options.diagnostics = nb::cast<bool>(value);
-          } else if (key_str == "spy") {
-            spy = nb::cast<bool>(value);
-          } else {
-            throw nb::key_error(
-                std::format("Invalid keyword argument: {}", key_str).c_str());
-          }
-        }
-
-        return self.solve(options, spy);
-      },
-      // XXX: The keyword argument docs are manually copied from the struct
-      // member docs in include/sleipnir/optimization/solver/options.hpp.
-      //
-      // C++'s Problem<double>::solve() takes an Options object instead of
-      // keyword arguments, so pybind11_mkdoc generates the wrong docs.
-      R"doc(Solves the optimization problem. The solution will be stored in the
-original variables used to construct the problem.
-
-Args:
-    tolerance: The solver will stop once the error is below this tolerance.
-        (default: 1e-8)
-    max_iterations: The maximum number of solver iterations before returning a
-        solution. (default: 5000)
-    timeout: The maximum elapsed wall clock time before returning a solution.
-        (default: infinity)
-    feasible_ipm: Enables the feasible interior-point method.
-
-        When the inequality constraints are all feasible, step sizes are reduced
-        when necessary to prevent them becoming infeasible again. This is useful
-        when parts of the problem are ill-conditioned in infeasible regions
-        (e.g., square root of a negative value). This can slow or prevent
-        progress toward a solution though, so only enable it if necessary.
-        (default: False)
-    diagnostics: Enables diagnostic output.
-
-        See https://sleipnirgroup.github.io/Sleipnir/md_usage.html#output for
-        more information. (default: False)
-    spy: Enables writing sparsity patterns of H, Aₑ, and Aᵢ to files named
-        H.spy, A_e.spy, and A_i.spy respectively during solve. Use tools/spy.py
-        to plot them. (default: False))doc");
-  cls.def(
-      "add_callback",
-      [](Problem<double>& self,
-         std::function<bool(const IterationInfo<double>& info)> callback) {
-        self.add_callback(std::move(callback));
-      },
-      "callback"_a, DOC(slp, Problem, add_callback, 2));
-  cls.def("clear_callbacks", &Problem<double>::clear_callbacks,
-          DOC(slp, Problem, clear_callbacks));
-}
-
-}  // namespace slp