Cython 3.2.0__cp39-abi3-win32.whl

Cython/Includes/libcpp/memory.pxd

@@ -0,0 +1,115 @@
+from libcpp cimport bool, nullptr_t, nullptr
+
+cdef extern from "<memory>" namespace "std" nogil:
+    cdef cppclass default_delete[T]:
+        default_delete()
+
+    cdef cppclass allocator[T]:
+        allocator()
+        allocator(const allocator &)
+        #allocator(const allocator[U] &) #unique_ptr unit tests fail w/this
+        T * address(T &)
+        const T * address(const T &) const
+        T * allocate( size_t n ) # Not to standard.  should be a second default argument
+        void deallocate(T * , size_t)
+        size_t max_size() const
+        void construct( T *, const T &) #C++98.  The C++11 version is variadic AND perfect-forwarding
+        void destroy(T *) #C++98
+        void destroy[U](U *) #unique_ptr unit tests fail w/this
+
+
+    cdef cppclass unique_ptr[T,DELETER=*]:
+        unique_ptr()
+        unique_ptr(nullptr_t)
+        unique_ptr(T*)
+        unique_ptr(unique_ptr[T]&)
+
+        # Modifiers
+        T* release()
+        void reset()
+        void reset(nullptr_t)
+        void reset(T*)
+        void swap(unique_ptr&)
+
+        # Observers
+        T* get()
+        T& operator*()
+        #T* operator->() # Not Supported
+        bool operator bool()
+        bool operator!()
+
+        bool operator==(const unique_ptr&)
+        bool operator!=(const unique_ptr&)
+        bool operator<(const unique_ptr&)
+        bool operator>(const unique_ptr&)
+        bool operator<=(const unique_ptr&)
+        bool operator>=(const unique_ptr&)
+
+        bool operator==(nullptr_t)
+        bool operator!=(nullptr_t)
+
+    # Forward Declaration not working ("Compiler crash in AnalyseDeclarationsTransform")
+    #cdef cppclass weak_ptr[T]
+
+    cdef cppclass shared_ptr[T]:
+        shared_ptr()
+        shared_ptr(nullptr_t)
+        shared_ptr(T*)
+        shared_ptr(shared_ptr[T]&)
+        shared_ptr(shared_ptr[T]&, T*)
+        shared_ptr(unique_ptr[T]&)
+        #shared_ptr(weak_ptr[T]&) # Not Supported
+        shared_ptr[T]& operator=[Y](const shared_ptr[Y]& ptr)
+
+        # Modifiers
+        void reset()
+        void reset(T*)
+        void swap(shared_ptr&)
+
+        # Observers
+        T* get()
+        T& operator*()
+        #T* operator->() # Not Supported
+        long use_count()
+        bool unique()
+        bool operator bool()
+        bool operator!()
+        #bool owner_before[Y](const weak_ptr[Y]&) # Not Supported
+        bool owner_before[Y](const shared_ptr[Y]&)
+
+        bool operator==(const shared_ptr&)
+        bool operator!=(const shared_ptr&)
+        bool operator<(const shared_ptr&)
+        bool operator>(const shared_ptr&)
+        bool operator<=(const shared_ptr&)
+        bool operator>=(const shared_ptr&)
+
+        bool operator==(nullptr_t)
+        bool operator!=(nullptr_t)
+
+    cdef cppclass weak_ptr[T]:
+        weak_ptr()
+        weak_ptr(weak_ptr[T]&)
+        weak_ptr(shared_ptr[T]&)
+
+        # Modifiers
+        void reset()
+        void swap(weak_ptr&)
+
+        # Observers
+        long use_count()
+        bool expired()
+        shared_ptr[T] lock()
+        bool owner_before[Y](const weak_ptr[Y]&)
+        bool owner_before[Y](const shared_ptr[Y]&)
+
+    # Smart pointer non-member operations
+    shared_ptr[T] make_shared[T](...) except +
+
+    unique_ptr[T] make_unique[T](...) except +
+
+    # No checking on the compatibility of T and U.
+    cdef shared_ptr[T] static_pointer_cast[T, U](const shared_ptr[U]&)
+    cdef shared_ptr[T] dynamic_pointer_cast[T, U](const shared_ptr[U]&)
+    cdef shared_ptr[T] const_pointer_cast[T, U](const shared_ptr[U]&)
+    cdef shared_ptr[T] reinterpret_pointer_cast[T, U](const shared_ptr[U]&)

Cython/Includes/libcpp/mutex.pxd

@@ -0,0 +1,387 @@
+# cython: preliminary_late_includes_cy28=True
+
+from libcpp cimport bool
+
+cdef extern from "<mutex>" namespace "std" nogil:
+    # For all these mutex classes, we strongly recommend you do not use any
+    # blocking lock function while holding the GIL (try_lock should be fine though).
+    cppclass mutex:
+        # may not be present, and we know nothing about it
+        cppclass native_handle_type:
+            pass
+
+        void lock() except+
+        bool try_lock()
+        void unlock()
+
+        native_handle_type native_handle() except+
+
+    cppclass timed_mutex:
+        # may not be present, and we know nothing about it
+        cppclass native_handle_type:
+            pass
+
+        void lock() except+
+        bool try_lock()
+        bool try_lock_for[T](const T& duration) except+
+        bool try_lock_until[T](const T& time_point) except+
+        void unlock()
+
+        native_handle_type native_handle() except+
+
+    # We strongly recommend not mixing recursive_mutex and the GIL at all.
+    # Because "unlock" may not actually unlock it, it's pretty hard to reason about
+    # avoiding deadlocks.
+    cppclass recursive_mutex:
+        # may not be present, and we know nothing about it
+        cppclass native_handle_type:
+            pass
+
+        void lock() except+
+        bool try_lock()
+        void unlock()
+
+        native_handle_type native_handle() except+
+
+    # We strongly recommend not mixing timed_recursive_mutex and the GIL at all.
+    # Because "unlock" may not actually unlock it, it's pretty hard to reason about
+    # avoiding deadlocks.
+    cppclass timed_recursive_mutex:
+        # may not be present, and we know nothing about it
+        cppclass native_handle_type:
+            pass
+
+        void lock() except+
+        bool try_lock()
+        bool try_lock_for[T](const T& duration) except+
+        bool try_lock_until[T](const T& time_point) except+
+        void unlock()
+
+        native_handle_type native_handle() except+
+
+
+    # tags
+    cppclass defer_lock_t:
+        pass
+    defer_lock_t defer_lock
+    cppclass try_to_lock_t:
+        pass
+    try_to_lock_t try_to_lock
+    cppclass adopt_lock_t:
+        pass
+    adopt_lock_t adopt_lock
+
+    # lock_guard is probably unusable without cpp_locals because it
+    # can't be default-constructed or moved.
+    # We strongly recommend you do not use this while holding the GIL.
+    # A safe way to construct with the GIL is to lock the mutex with py_safe_lock
+    # and then construct the lock guard with adopt_lock_t.
+    cppclass lock_guard[T]:
+        ctypedef T mutex_type
+        lock_guard(mutex_type&) except+
+        lock_guard(mutex_type&, adopt_lock_t)
+
+    # We strongly recommend that you do not use any blocking lock function with the GIL.
+    # (try_lock is fine though).
+    cppclass unique_lock[T]:
+        ctypedef T mutex_type
+        unique_lock()
+        # This covers both the plain regular constructor, the 3 versions with tags
+        # and two std::chrono constructors.  The two templated chrono versions stop
+        # us from declaring the overloads explicitly.
+        unique_lock(mutex_type&, ...) except+
+        #unique_lock(mutex_type&, defer_lock_t)
+        #unique_lock(mutex_type&, try_to_lock_t) except+
+        ## this feels like it should be noexcet, but cppreference implies it isn't
+        #unique_lock(mutex_type&, adopt_lock_t) except+
+
+        void lock() except+
+        bool try_lock() except+
+        bool try_lock_for[T](const T& duration) except+
+        bool try_lock_until[T](const T& time_point) except+
+        void unlock() except+
+
+        void swap(unique_lock& other)
+        # "release" is definitely not the same as unlock. Noted here because
+        # DW always makes this mistake and regrets it and wants to save you
+        # from the same fate.
+        mutex_type* release()
+
+        mutex_type* mutex()
+        bool owns_lock()
+        bool operator bool()
+
+    # scoped lock is probably unusable without cpp_locals.
+    # It's also a variadic template type so can take potentially unlimited number of
+    # arguments. Cython doesn't support this, so if you want more than 26 arguments,
+    # you're on your own.
+    # We strongly recommend that you do not use this while holding the GIL.
+    # The safe way to use it when holding the GIL is to:
+    # 1. first lock the mutexes with py_safe_lock
+    # 2. construct scoped_lock with adopt_lock as the first argument
+    cppclass scoped_lock[A=*, B=*, C=*, D=*, E=*, F=*, G=*, H=*, I=*, J=*, K=*,
+                         L=*, M=*, N=*, O=*, P=*, Q=*, R=*, S=*, T=*, U=*, V=*,
+                         W=*, X=*, Y=*, Z=*]:
+        scoped_lock(...) except+
+
+    cppclass once_flag:
+        pass
+
+    bool try_lock(...) except+
+    # We strongly recommend that you do not call "lock" while holding the GIL.
+    # See py_safe_lock.
+    void lock(...) except+
+
+    # We can't enforce this in the interface, but you need to make sure that Callable
+    # doesn't require the GIL and doesn't throw Python exceptions.
+    # You should also not call this with the GIL held.
+    # We strong recommend using the py_safe_call_once wrappers below if you require the GIL.
+    void call_once[Callable](once_flag&, Callable& callable,  ...) except +
+
+
+cdef inline void _dummy_force_utility_code_inclusion() nogil:
+    with nogil:
+        pass
+
+cdef extern from *:
+    # Treat this as a different type from Cython's point of view so that if users use our safe functions
+    # then they can't mix them with the unsafe functions using the same flag.
+    cdef cppclass py_safe_once_flag "std::once_flag":
+        pass
+
+# Cython-specific wrappers to avoid deadlock.
+# If you're holding the GIL then we strongly recommend you use these.
+cdef extern from *:
+    """
+    #include <utility>
+    #include <exception>
+
+    namespace {
+
+    static PyGILState_STATE __pyx_libcpp_mutex_limited_api_ensure_gil() {
+        #if CYTHON_COMPILING_IN_LIMITED_API
+        if ((__PYX_LIMITED_VERSION_HEX < 0x030d0000) && __Pyx_get_runtime_version() < 0x030d0000) {
+            return PyGILState_Ensure();
+        }
+        #endif
+        return PyGILState_LOCKED;  // Unused
+    }
+
+    #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000
+    static void __pyx_libcpp_mutex_limited_api_release_gil(PyGILState_STATE gil_state) {
+        if (__Pyx_get_runtime_version() < 0x030d0000)
+            PyGILState_Release(gil_state);
+    }
+    #else
+    #define __pyx_libcpp_mutex_limited_api_release_gil(ignore) (void)ignore
+    #endif
+
+    static int __pyx_libcpp_mutex_has_gil() {
+        #if CYTHON_COMPILING_IN_LIMITED_API
+            if ((__PYX_LIMITED_VERSION_HEX >= 0x030d0000) || __Pyx_get_runtime_version() >= 0x030d0000) {
+                // In 3.13+ we can temporarily give up the GIL to find out what the thread state was
+                PyThreadState *ts = PyThreadState_Swap(NULL);
+                if (ts) {
+                    PyThreadState_Swap(ts);
+                    return 1;
+                }
+                return 0;
+            }
+            /* There is no way to know if we have the GIL. Therefore the only
+            * thing we can safely do is make absolutely sure that we have it
+            * in (__pyx_libcpp_mutex_limited_api_ensure_gil).
+            */
+            return 1;
+        #elif PY_VERSION_HEX >= 0x030d0000
+            return PyThreadState_GetUnchecked() != NULL;
+        #elif PY_VERSION_HEX >= 0x030b0000
+            return _PyThreadState_UncheckedGet() != NULL;
+        #else
+            return PyGILState_Check();
+        #endif
+    }
+
+    template <typename F>
+    class __pyx_libcpp_mutex_cleanup_on_exit {
+        F on_exit;
+        bool invoke = true;
+
+    public:
+        explicit __pyx_libcpp_mutex_cleanup_on_exit(F f)
+            : on_exit(f)
+        {}
+        __pyx_libcpp_mutex_cleanup_on_exit(__pyx_libcpp_mutex_cleanup_on_exit &&rhs)
+            : on_exit(std::move(rhs.on_exit))
+            , invoke(rhs.invoke)
+        {
+            rhs.invoke = false;
+        }
+
+        __pyx_libcpp_mutex_cleanup_on_exit(const __pyx_libcpp_mutex_cleanup_on_exit&) = delete;
+        __pyx_libcpp_mutex_cleanup_on_exit& operator=(const __pyx_libcpp_mutex_cleanup_on_exit&) = delete;
+
+        ~__pyx_libcpp_mutex_cleanup_on_exit() {
+            if (invoke)
+                on_exit();
+        }
+    };
+
+    template<typename F>
+    __pyx_libcpp_mutex_cleanup_on_exit<F> __pyx_make_libcpp_mutex_cleanup_on_exit(F f) {
+        return __pyx_libcpp_mutex_cleanup_on_exit<F>(std::move(f));
+    }
+
+    template <typename Callable, typename ... Args>
+    void __pyx_cpp_py_safe_call_once(std::once_flag& flag, Callable& callable, Args&&... args) {
+        class PyException : public std::exception {
+        public:
+            using std::exception::exception;
+        };
+
+        __Pyx_UnknownThreadState thread_state = __Pyx_SaveUnknownThread();
+        auto on_exit = __pyx_make_libcpp_mutex_cleanup_on_exit(
+            [&]() {
+                __Pyx_RestoreUnknownThread(thread_state);
+            });
+
+        try {
+            std::call_once(flag,
+                [&](Args& ...args) {
+                    // Make sure we have the GIL
+                    PyGILState_STATE gil_state;
+                    int had_gil_on_call = __Pyx_UnknownThreadStateDefinitelyHadGil(thread_state);
+                    if (had_gil_on_call) {
+                        __Pyx_RestoreUnknownThread(thread_state);
+                    } else {
+                        gil_state = PyGILState_Ensure();
+                    }
+                    auto on_callable_exit = __pyx_make_libcpp_mutex_cleanup_on_exit(
+                        [&]() {
+                            if (had_gil_on_call) {
+                                thread_state = __Pyx_SaveUnknownThread();
+                            } else {
+                                PyGILState_Release(gil_state);
+                            }
+                        });
+
+                    std::forward<Callable>(callable)(std::forward<Args>(args)...);
+                    if (PyErr_Occurred()) {
+                        throw PyException();
+                    }
+                },
+                std::forward<Args>(args)...
+            );
+        } catch (const PyException&) {
+            // Do nothing
+        }
+    }
+
+    CYTHON_UNUSED void __pyx_cpp_py_safe_call_object_once(std::once_flag& flag, PyObject *py_callable) {
+        auto callable = [py_callable]() {
+            auto result = PyObject_CallObject(py_callable, nullptr);
+            Py_XDECREF(result);
+        };
+        __pyx_cpp_py_safe_call_once(flag, callable);
+    }
+
+    template <typename LockableT>
+    void __pyx_std_lock_wrapper(LockableT& arg0) {
+        // std::lock only handles 2 or more arguments.
+        // So create a 1 argument version.
+        arg0.lock();
+    }
+
+    template <typename Lockable0T, typename Lockable1T, typename ... Lockables>
+    void __pyx_std_lock_wrapper(Lockable0T& arg0, Lockable1T& arg1, Lockables&... args) {
+        std::lock(arg0, arg1, args...);
+    }
+
+    inline void __pyx_libcpp_mutex_unlock() {} // no-op
+
+    template <typename Lockable0T, typename ... Lockables>
+    void __pyx_libcpp_mutex_unlock(Lockable0T& arg0, Lockables&... locks) {
+        arg0.unlock();
+        __pyx_libcpp_mutex_unlock(locks...);
+    }
+
+    template <typename LockableT>
+    int __pyx_std_try_lock_wrapper(LockableT& arg0) {
+        // std::try_lock only handles 2 or more arguments.
+        // So create a 1 argument version.
+        if (arg0.try_lock()) {
+            return -1;
+        }
+        return 0;
+    }
+
+    template <typename Lockable0T, typename Lockable1T, typename ...Lockables>
+    int __pyx_std_try_lock_wrapper(Lockable0T& arg0, Lockable1T& arg1, Lockables&... args) {
+        return std::try_lock(arg0, arg1, args...);
+    }
+
+    template <typename... LockTs>
+    void __pyx_py_safe_std_lock_release_lock_reacquire(LockTs& ...locks) {
+        // Release the GIL, acquire the lock, then reacquire the GIL.
+        // This is safe provided the user never holds the GIL while trying
+        // to reacquire the lock (i.e. it's safe provided they always use
+        // the py-safe wrappers).
+        PyThreadState *_save;
+        Py_UNBLOCK_THREADS
+        try {
+            __pyx_std_lock_wrapper(locks...);
+        } catch (...) {
+            // In this case, we probably can't reason about the state of the locks but we can at least
+            // make sure the GIL is consistent.
+            Py_BLOCK_THREADS
+            throw;
+        }
+        Py_BLOCK_THREADS
+        return;
+    }
+
+    template <typename... LockTs>
+    void __pyx_py_safe_std_lock(LockTs& ...locks) {
+        PyGILState_STATE gil_state = __pyx_libcpp_mutex_limited_api_ensure_gil();
+        int had_gil_on_call = __pyx_libcpp_mutex_has_gil();
+        auto on_exit = __pyx_make_libcpp_mutex_cleanup_on_exit(
+            [&]() {
+                __pyx_libcpp_mutex_limited_api_release_gil(gil_state);
+            });
+        if (!had_gil_on_call) {
+            // Nothing special to do - just lock and quit
+            __pyx_std_lock_wrapper(locks...);
+            return;
+        }
+
+        // It's a real shame there's no try_lock for the GIL, otherwise
+        // we could just defer this whole thing to c++ std::lock.
+        if (__pyx_std_try_lock_wrapper(locks...) == -1) {
+            // success!
+            return;
+        }
+        __pyx_py_safe_std_lock_release_lock_reacquire(locks...);
+    }
+
+    template <typename MutexT>
+    std::unique_lock<MutexT> __pyx_py_safe_construct_unique_lock(MutexT& mutex) {
+        std::unique_lock<MutexT> l{mutex, std::defer_lock};
+        __pyx_py_safe_std_lock(l);
+        return l;
+    }
+    } // namespace
+    """
+    # Call a Python callable once, ensuring that the GIL is released before locking, and the callable
+    # is called with the GIL held. The callable may be a Python object or C function.
+    # If using a generic callable, the callable can throw either Python
+    # or C++ exceptions. Both are treated like a C++ exception.
+    # The GIL state on exit is the same as on entry.
+    void py_safe_call_object_once "__pyx_cpp_py_safe_call_object_once" (py_safe_once_flag&, object callable) except +* nogil
+    void py_safe_call_once "__pyx_cpp_py_safe_call_once" [Callable](py_safe_once_flag&, Callable callable, ...) except +* nogil
+
+    # Call std::lock on the lockable objects with the GIL held, avoiding deadlock with the GIL.
+    # (Unlike the standard library version, it works with a single argument).
+    # The GIL state on exit is the same as on entry.
+    void py_safe_lock "__pyx_py_safe_std_lock" (...) except+ nogil
+
+    # construct a unique lock with the GIL held, avoiding deadlocks with the GIL
+    unique_lock[MutexT] py_safe_construct_unique_lock "__pyx_py_safe_construct_unique_lock" [MutexT](MutexT& m) except+ nogil

Cython/Includes/libcpp/numbers.pxd

@@ -0,0 +1,15 @@
+cdef extern from "<numbers>" namespace "std::numbers" nogil:
+    # C++20 mathematical constants
+    const double e
+    const double log2e
+    const double log10e
+    const double pi
+    const double inv_pi
+    const double inv_sqrtpi
+    const double ln2
+    const double ln10
+    const double sqrt2
+    const double sqrt3
+    const double inv_sqrt3
+    const double egamma
+    const double phi

Cython/Includes/libcpp/numeric.pxd

@@ -0,0 +1,131 @@
+cdef extern from "<numeric>" namespace "std" nogil:
+    T inner_product[InputIt1, InputIt2, T](InputIt1 first1, InputIt1 last1, InputIt2 first2, T init)
+
+    T inner_product[InputIt1, InputIt2, T, BinaryOperation1, BinaryOperation2](InputIt1 first1, InputIt1 last1,
+                                                                               InputIt2 first2, T init,
+                                                                               BinaryOperation1 op1,
+                                                                               BinaryOperation2 op2)
+
+    void iota[ForwardIt, T](ForwardIt first, ForwardIt last, T value)
+
+    T accumulate[InputIt, T](InputIt first, InputIt last, T init)
+
+    T accumulate[InputIt, T, BinaryOperation](InputIt first, InputIt last, T init, BinaryOperation op)
+
+    void adjacent_difference[InputIt, OutputIt](InputIt in_first, InputIt in_last, OutputIt out_first)
+
+    void adjacent_difference[InputIt, OutputIt, BinaryOperation](InputIt in_first, InputIt in_last, OutputIt out_first,
+                                                                 BinaryOperation op)
+
+    void partial_sum[InputIt, OutputIt](InputIt in_first, InputIt in_last, OutputIt out_first)
+
+    void partial_sum[InputIt, OutputIt, BinaryOperation](InputIt in_first, InputIt in_last, OutputIt out_first,
+                                                         BinaryOperation op)
+
+
+    T reduce[InputIt, T](InputIt first, InputIt last, T init)
+
+    # ambiguous with next overload
+    #T reduce[ExecutionPolicy, ForwardIt, T](ExecutionPolicy&& policy,
+    #    ForwardIt first, ForwardIt last, T init)
+
+    T reduce[InputIt, T, BinaryOp](InputIt first, InputIt last, T init, BinaryOp binary_op)
+
+    T reduce[ExecutionPolicy, ForwardIt, T, BinaryOp](ExecutionPolicy&& policy,
+        ForwardIt first, ForwardIt last, T init, BinaryOp binary_op)
+
+    T transform_reduce[InputIt1, InputIt2, T](InputIt1 first1, InputIt1 last1,
+        InputIt2 first2, T init)
+
+    T transform_reduce[InputIt1, InputIt2, T, BinaryReductionOp, BinaryTransformOp](
+        InputIt1 first1, InputIt1 last1, InputIt2 first2, T init,
+        BinaryReductionOp reduce, BinaryTransformOp transform)
+
+    T transform_reduce[InputIt, T, BinaryReductionOp, UnaryTransformOp](
+        InputIt first, InputIt last, T init, BinaryReductionOp reduce,
+        UnaryTransformOp transform)
+
+    # ambiguous with previous overload
+    #T transform_reduce[ExecutionPolicy, ForwardIt1, ForwardIt2, T](
+    #    ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1,
+    #    ForwardIt2 first2, T init)
+
+    T transform_reduce[ExecutionPolicy, ForwardIt1, ForwardIt2, T, BinaryReductionOp, BinaryTransformOp](
+        ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, T init,
+        BinaryReductionOp reduce, BinaryTransformOp transform)
+
+    # ambiguous with second overload
+    #T transform_reduce[ExecutionPolicy, ForwardIt, T, BinaryReductionOp, UnaryTransformOp](
+    #    ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, T init, BinaryReductionOp reduce,
+    #    UnaryTransformOp transform)
+
+    OutputIt inclusive_scan[InputIt, OutputIt](InputIt first, InputIt last, OutputIt d_first)
+
+    # ambiguous with next overload
+    # ForwardIt2 inclusive_scan[ExecutionPolicy, ForwardIt1, ForwardIt2](
+    #    ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last,
+    #    ForwardIt2 d_first)
+
+    OutputIt inclusive_scan[InputIt, OutputIt, BinaryOperation](
+        InputIt first, InputIt last, OutputIt d_first, BinaryOperation binary_op)
+
+    # ambiguous with next overload
+    # ForwardIt2 inclusive_scan[ExecutionPolicy, ForwardIt1, ForwardIt2, BinaryOperation](
+    #   ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
+    #   BinaryOperation binary_op)
+
+    OutputIt inclusive_scan[InputIt, OutputIt, BinaryOperation, T](
+        InputIt first, InputIt last, OutputIt d_first, BinaryOperation binary_op,
+        T init)
+
+    #
+    # ForwardIt2 inclusive_scan[ExecutionPolicy, ForwardIt1, ForwardIt2, BinaryOperation, T](
+    #     ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
+    #     BinaryOperation binary_op, T init)
+
+    OutputIt exclusive_scan[InputIt, OutputIt, T](InputIt first, InputIt last,
+        OutputIt d_first, T init)
+
+    # ambiguous with next overload
+    #ForwardIt2 exclusive_scan[ExecutionPolicy, ForwardIt1, ForwardIt2, T](
+    #    ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last,
+    #    ForwardIt2 d_first, T init)
+
+    OutputIt exclusive_scan[InputIt, OutputIt, T, BinaryOperation](
+        InputIt first, InputIt last, OutputIt d_first, T init, BinaryOperation binary_op)
+
+    ForwardIt2 exclusive_scan[ExecutionPolicy, ForwardIt1, ForwardIt2, T, BinaryOperation](
+        ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
+        T init, BinaryOperation binary_op)
+
+    OutputIt transform_inclusive_scan[InputIt, OutputIt, BinaryOperation, UnaryOperation](
+        InputIt first, InputIt last, OutputIt d_first, BinaryOperation binary_op,
+        UnaryOperation unary_op)
+
+    # ambiguous with next overload
+    # ForwardIt2 transform_inclusive_scan[ExecutionPolicy, ForwardIt1, ForwardIt2, BinaryOperation, UnaryOperation](
+    #    ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
+    #    BinaryOperation binary_op, UnaryOperation unary_op)
+
+    OutputIt transform_inclusive_scan[InputIt, OutputIt, BinaryOperation, UnaryOperation, T](
+        InputIt first, InputIt last, OutputIt d_first, BinaryOperation binary_op,
+        UnaryOperation unary_op, T init)
+
+    ForwardIt2 transform_inclusive_scan[ExecutionPolicy, ForwardIt1, ForwardIt2, BinaryOperation, UnaryOperation, T](
+        ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
+        BinaryOperation binary_op, UnaryOperation unary_op, T init)
+
+    OutputIt transform_exclusive_scan[InputIt, OutputIt, T, BinaryOperation, UnaryOperation](
+        InputIt first, InputIt last, OutputIt d_first, T init, BinaryOperation binary_op,
+        UnaryOperation unary_op)
+
+    ForwardIt2 transform_exclusive_scan[ExecutionPolicy, ForwardIt1, ForwardIt2, T, BinaryOperation, UnaryOperation](
+        ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
+        T init, BinaryOperation binary_op, UnaryOperation unary_op)
+
+    # C++17
+    T gcd[T](T a, T b)
+    T lcm[T](T a, T b)
+
+    # C++20
+    T midpoint[T](T a, T b) except +

Cython/Includes/libcpp/optional.pxd

@@ -0,0 +1,34 @@
+from libcpp cimport bool
+
+cdef extern from "<optional>" namespace "std" nogil:
+    cdef cppclass nullopt_t:
+        nullopt_t()
+
+    cdef nullopt_t nullopt
+
+    cdef cppclass optional[T]:
+        ctypedef T value_type
+        optional()
+        optional(nullopt_t)
+        optional(optional&) except +
+        optional(T&) except +
+        bool has_value()
+        T& value() except +
+        T& value_or[U](U& default_value)
+        void swap(optional&)
+        void reset()
+        T& emplace(...)
+        T& operator*()
+        #T* operator->() # Not Supported
+        optional& operator=(optional&)
+        optional& operator=[U](U&)
+        bool operator bool()
+        bool operator!()
+        bool operator==[U](optional&, U&)
+        bool operator!=[U](optional&, U&)
+        bool operator<[U](optional&, U&)
+        bool operator>[U](optional&, U&)
+        bool operator<=[U](optional&, U&)
+        bool operator>=[U](optional&, U&)
+
+    optional[T] make_optional[T](...) except +

Cython/Includes/libcpp/pair.pxd

@@ -0,0 +1 @@
+from .utility cimport pair