PERF: optimize _libs.algos for SIMD auto-vectorization and GIL release

- diff_2d: use raw C pointers for inner loops so the C compiler can
  auto-vectorize the subtraction (~20-25% faster for DataFrame.diff)
- take_2d_axis0/axis1: use raw C pointers for inner row copy/conversion
  loops enabling auto-vectorization (~10% faster for cross-type reindex)
- nancorr: add no_nans fast path skipping per-element mask checks
- nancorr_spearman: add @cython.cdivision(True)
- rank_sorted_1d: add @cython.cdivision(True) to remove zero-division
  checks from the hot ranking loop
- rank_1d: skip unnecessary putmask when check_mask is False
- pad/backfill/pad_inplace/pad_2d_inplace: release GIL for numeric types
- get_fill_indexer: release GIL
- unique_deltas: use C array instead of Python list to avoid GIL
  interaction per unique delta
- is_monotonic: remove redundant assignments before break

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jbrockmendel

doc/source/whatsnew/v3.1.0.rst

@@ -136,6 +136,8 @@ Performance improvements
 - Performance improvement in :func:`read_sas` for compressed SAS7BDAT files by reusing the decompression buffer instead of allocating per row (:issue:`47339`)
 - Performance improvement in :func:`read_sas` when decoding strings (:issue:`47339`)
 - Performance improvement in :func:`util.hash_pandas_object` for PyArrow-backed string and binary types by using PyArrow's ``dictionary_encode`` instead of converting to NumPy for factorization (:issue:`48964`)
+- Performance improvement in :meth:`DataFrame.corr` and :meth:`DataFrame.cov` when data contains no NaN values (:issue:`64857`)
+- Performance improvement in :meth:`DataFrame.diff` by using raw C pointers to enable auto-vectorization of the inner loop (:issue:`64857`)
 - Performance improvement in :meth:`DataFrame.from_records` when passing a 2D :class:`numpy.ndarray` (:issue:`22025`)
 - Performance improvement in :meth:`DataFrame.insert` when the number of blocks is small (:issue:`57641`)
 - Performance improvement in :meth:`DataFrame.loc` with non-unique masked index (:issue:`56759`)
@@ -151,6 +153,7 @@ Performance improvements
 - Performance improvement in datetime/timedelta unit conversion (e.g. ``datetime64[s]`` to ``datetime64[ns]``) (:issue:`35025`)
 - Performance improvement in indexing a :class:`DataFrame` with a :class:`CategoricalIndex` of :class:`Interval` categories (:issue:`61928`)
 - Performance improvement in indexing a :class:`MultiIndex` with a list-like indexer (:issue:`55786`)
+- Performance improvement in indexing operations that use ``take_2d`` (e.g. :meth:`DataFrame.reindex`) by using raw C pointers to enable auto-vectorization of the inner row copy (:issue:`64857`)
 - Performance improvement in partial-string indexing on a monotonic decreasing :class:`DatetimeIndex` or :class:`PeriodIndex` (:issue:`64811`)
 - Performance improvement in plotting :class:`DatetimeIndex` with multiplied frequencies (e.g. ``"1000ms"``, ``"100s"``) (:issue:`50355`)
 - Performance improvement in reading zip-compressed files (e.g. :func:`read_pickle`, :func:`read_csv`) on Python < 3.12 (:issue:`59279`)

pandas/_libs/algos.pyx

@@ -136,25 +136,37 @@ cpdef ndarray[int64_t, ndim=1] unique_deltas(const int64_t[:] arr):
         An ordered ndarray[int64_t]
     """
     cdef:
-        Py_ssize_t i, n = len(arr)
+        Py_ssize_t i, n = len(arr), num_uniques = 0
         int64_t val
         khiter_t k
         kh_int64_t *table
         int ret = 0
-        list uniques = []
+        int64_t *uniques = NULL
         ndarray[int64_t, ndim=1] result
 
     table = kh_init_int64()
     kh_resize_int64(table, 10)
+
+    # n - 1 is the max possible number of unique deltas
+    if n > 1:
+        uniques = <int64_t*>malloc((n - 1) * sizeof(int64_t))
+        if uniques is NULL:
+            kh_destroy_int64(table)
+            raise MemoryError()
+
     for i in range(n - 1):
         val = arr[i + 1] - arr[i]
         k = kh_get_int64(table, val)
         if k == table.n_buckets:
             kh_put_int64(table, val, &ret)
-            uniques.append(val)
+            uniques[num_uniques] = val
+            num_uniques += 1
     kh_destroy_int64(table)
 
-    result = np.array(uniques, dtype=np.int64)
+    result = np.empty(num_uniques, dtype=np.int64)
+    if num_uniques > 0:
+        memcpy(cnp.PyArray_DATA(result), uniques, num_uniques * sizeof(int64_t))
+    free(uniques)
     result.sort()
     return result
 
@@ -347,6 +359,7 @@ def nancorr(const float64_t[:, :] mat, bint cov=False, minp=None):
         uint8_t[:, :] mask
         int64_t nobs = 0
         float64_t vx, vy, dx, dy, meanx, meany, divisor, ssqdmx, ssqdmy, covxy, val
+        bint no_nans
 
     N, K = (<object>mat).shape
     if minp is None:
@@ -356,25 +369,40 @@ def nancorr(const float64_t[:, :] mat, bint cov=False, minp=None):
 
     result = np.empty((K, K), dtype=np.float64)
     mask = np.isfinite(mat).view(np.uint8)
+    no_nans = np.asarray(mask).all()
 
     with nogil:
         for xi in range(K):
             for yi in range(xi + 1):
                 # Welford's method for the variance-calculation
                 # https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
                 nobs = ssqdmx = ssqdmy = covxy = meanx = meany = 0
-                for i in range(N):
-                    if mask[i, xi] and mask[i, yi]:
+
+                if no_nans:
+                    nobs = N
+                    for i in range(N):
                         vx = mat[i, xi]
                         vy = mat[i, yi]
-                        nobs += 1
                         dx = vx - meanx
                         dy = vy - meany
-                        meanx += 1. / nobs * dx
-                        meany += 1. / nobs * dy
+                        meanx += 1. / (i + 1) * dx
+                        meany += 1. / (i + 1) * dy
                         ssqdmx += (vx - meanx) * dx
                         ssqdmy += (vy - meany) * dy
                         covxy += (vx - meanx) * dy
+                else:
+                    for i in range(N):
+                        if mask[i, xi] and mask[i, yi]:
+                            vx = mat[i, xi]
+                            vy = mat[i, yi]
+                            nobs += 1
+                            dx = vx - meanx
+                            dy = vy - meany
+                            meanx += 1. / nobs * dx
+                            meany += 1. / nobs * dy
+                            ssqdmx += (vx - meanx) * dx
+                            ssqdmy += (vy - meany) * dy
+                            covxy += (vx - meanx) * dy
 
                 if nobs < minpv:
                     result[xi, yi] = result[yi, xi] = NaN
@@ -843,8 +871,6 @@ def is_monotonic(const numeric_object_t[:] arr, bint timelike):
                 is_monotonic_dec = 0
                 break
             if not is_monotonic_inc and not is_monotonic_dec:
-                is_monotonic_inc = 0
-                is_monotonic_dec = 0
                 break
             prev = cur
 
@@ -1022,7 +1048,6 @@ def rank_1d(
     # will flip the ordering to still end up with lowest rank.
     # Symmetric logic applies to `na_option == 'bottom'`
     nans_rank_highest = ascending ^ (na_option == "top")
-    nan_fill_val = get_rank_nan_fill_val(nans_rank_highest, <numeric_object_t>0)
     if nans_rank_highest:
         order = [masked_vals, mask]
     else:
@@ -1031,7 +1056,9 @@ def rank_1d(
     if check_labels:
         order.append(labels)
 
-    np.putmask(masked_vals, mask, nan_fill_val)
+    if check_mask:
+        nan_fill_val = get_rank_nan_fill_val(nans_rank_highest, <numeric_object_t>0)
+        np.putmask(masked_vals, mask, nan_fill_val)
     # putmask doesn't accept a memoryview, so we assign as a separate step
     masked_vals_memview = masked_vals
 
@@ -1356,7 +1383,7 @@ ctypedef fused out_t:
 @cython.wraparound(False)
 def diff_2d(
     const diff_t[:, :] arr,
-    ndarray[out_t, ndim=2] out,
+    out_t[:, :] out,
     Py_ssize_t periods,
     int axis,
     bint datetimelike=False,
@@ -1365,6 +1392,15 @@ def diff_2d(
         Py_ssize_t i, j, sx, sy, start, stop
         bint f_contig = arr.is_f_contig()
         diff_t left, right
+        # Raw pointer variables for auto-vectorization of inner loops.
+        # Memoryview indexing generates strided pointer arithmetic that
+        # prevents the C compiler from auto-vectorizing even when the
+        # data is contiguous. Using raw typed pointers gives the compiler
+        # unit-stride access patterns it can vectorize.
+        const diff_t *arr_row
+        const diff_t *arr_prev_row
+        out_t *out_row
+        bint rows_contiguous
 
     # Disable for unsupported dtype combinations,
     #  see https://github.com/cython/cython/issues/2646
@@ -1381,6 +1417,13 @@ def diff_2d(
         # We put this inside an indented else block to avoid cython build
         #  warnings about unreachable code
         sx, sy = (<object>arr).shape
+
+        # Check whether both arrays have unit stride along axis 1 (columns),
+        # i.e. rows are contiguous. When true, inner loops over j can use
+        # raw C pointers enabling SIMD auto-vectorization.
+        rows_contiguous = (arr.strides[1] == <Py_ssize_t>sizeof(diff_t) and
+                           out.strides[1] == <Py_ssize_t>sizeof(out_t))
+
         with nogil:
             if f_contig:
                 if axis == 0:
@@ -1421,33 +1464,64 @@ def diff_2d(
                         start, stop = periods, sx
                     else:
                         start, stop = 0, sx + periods
-                    for i in range(start, stop):
-                        for j in range(sy):
-                            left = arr[i, j]
-                            right = arr[i - periods, j]
-                            if out_t is int64_t and datetimelike:
-                                if left == NPY_NAT or right == NPY_NAT:
-                                    out[i, j] = NPY_NAT
+                    if rows_contiguous:
+                        for i in range(start, stop):
+                            arr_row = &arr[i, 0]
+                            arr_prev_row = &arr[i - periods, 0]
+                            out_row = &out[i, 0]
+                            for j in range(sy):
+                                if out_t is int64_t and datetimelike:
+                                    left = arr_row[j]
+                                    right = arr_prev_row[j]
+                                    if left == NPY_NAT or right == NPY_NAT:
+                                        out_row[j] = NPY_NAT
+                                    else:
+                                        out_row[j] = left - right
+                                else:
+                                    out_row[j] = arr_row[j] - arr_prev_row[j]
+                    else:
+                        for i in range(start, stop):
+                            for j in range(sy):
+                                left = arr[i, j]
+                                right = arr[i - periods, j]
+                                if out_t is int64_t and datetimelike:
+                                    if left == NPY_NAT or right == NPY_NAT:
+                                        out[i, j] = NPY_NAT
+                                    else:
+                                        out[i, j] = left - right
                                 else:
                                     out[i, j] = left - right
-                            else:
-                                out[i, j] = left - right
                 else:
                     if periods >= 0:
                         start, stop = periods, sy
                     else:
                         start, stop = 0, sy + periods
-                    for i in range(sx):
-                        for j in range(start, stop):
-                            left = arr[i, j]
-                            right = arr[i, j - periods]
-                            if out_t is int64_t and datetimelike:
-                                if left == NPY_NAT or right == NPY_NAT:
-                                    out[i, j] = NPY_NAT
+                    if rows_contiguous:
+                        for i in range(sx):
+                            arr_row = &arr[i, 0]
+                            out_row = &out[i, 0]
+                            for j in range(start, stop):
+                                if out_t is int64_t and datetimelike:
+                                    left = arr_row[j]
+                                    right = arr_row[j - periods]
+                                    if left == NPY_NAT or right == NPY_NAT:
+                                        out_row[j] = NPY_NAT
+                                    else:
+                                        out_row[j] = left - right
+                                else:
+                                    out_row[j] = arr_row[j] - arr_row[j - periods]
+                    else:
+                        for i in range(sx):
+                            for j in range(start, stop):
+                                left = arr[i, j]
+                                right = arr[i, j - periods]
+                                if out_t is int64_t and datetimelike:
+                                    if left == NPY_NAT or right == NPY_NAT:
+                                        out[i, j] = NPY_NAT
+                                    else:
+                                        out[i, j] = left - right
                                 else:
                                     out[i, j] = left - right
-                            else:
-                                out[i, j] = left - right
 
 
 # ----------------------------------------------------------------------