numpy
diff --git a/‎numpy/lib/function_base.py
Lines changed: 33 additions & 37 deletions b/‎numpy/lib/function_base.py
Lines changed: 33 additions & 37 deletions
diff --git a/‎numpy/lib/nanfunctions.py
Lines changed: 6 additions & 6 deletions b/‎numpy/lib/nanfunctions.py
Lines changed: 6 additions & 6 deletions
diff --git a/‎numpy/lib/tests/test_function_base.py
Lines changed: 6 additions & 17 deletions b/‎numpy/lib/tests/test_function_base.py
Lines changed: 6 additions & 17 deletions
diff --git a/‎numpy/lib/tests/test_nanfunctions.py
Lines changed: 3 additions & 14 deletions b/‎numpy/lib/tests/test_nanfunctions.py
Lines changed: 3 additions & 14 deletions
@@ -2017,7 +2017,7 @@ def disp(mesg, device=None, linefeed=True):
         "(deprecated in NumPy 2.0)",
         DeprecationWarning,
         stacklevel=2
-    )    
+    )
 
     if device is None:
         device = sys.stdout
@@ -3984,22 +3984,22 @@ def _median(a, axis=None, out=None, overwrite_input=False):
     return rout
 
 
-def _percentile_dispatcher(a, q, axis=None, weights=None, out=None,
+def _percentile_dispatcher(a, q, axis=None, out=None,
                            overwrite_input=None, method=None, keepdims=None, *,
-                           interpolation=None):
+                           weights=None, interpolation=None):
     return (a, q, out)
 
 
 @array_function_dispatch(_percentile_dispatcher)
 def percentile(a,
                q,
                axis=None,
-               weights=None,
                out=None,
                overwrite_input=False,
                method="linear",
                keepdims=False,
                *,
+               weights=None,
                interpolation=None):
     """
     Compute the q-th percentile of the data along the specified axis.
@@ -4319,22 +4319,22 @@ def percentile(a,
         a, q, axis, weights, out, overwrite_input, method, keepdims)
 
 
-def _quantile_dispatcher(a, q, axis=None, weights=None, out=None,
+def _quantile_dispatcher(a, q, axis=None, out=None,
                          overwrite_input=None, method=None, keepdims=None, *,
-                         interpolation=None):
+                         weights=None, interpolation=None):
     return (a, q, out)
 
 
 @array_function_dispatch(_quantile_dispatcher)
 def quantile(a,
              q,
              axis=None,
-             weights=None,
              out=None,
              overwrite_input=False,
              method="linear",
              keepdims=False,
              *,
+             weights=None,
              interpolation=None):
     """
     Compute the q-th quantile of the data along the specified axis.
@@ -4647,11 +4647,10 @@ def _validate_and_ureduce_weights(a, axis, wgts):
 
     Weights cannot:
         * be negative
+        * be (0, 1)
         * sum to 0
     However, they can be
         * 0, as long as they do not sum to 0
-        * less than 1.  In this case, all weights are re-normalized by
-            the lowest non-zero weight prior to computation.
 
     Weights will be broadcasted to the shape of a, then reduced as done
     via _ureduce().
@@ -4678,6 +4677,9 @@ def _validate_and_ureduce_weights(a, axis, wgts):
     if (wgts < 0).any():
         raise ValueError("Negative weight not allowed.")
 
+    if ((0 < wgts) & (wgts < 1)).any():
+        raise ValueError("Partial weight (0, 1) not allowed.")
+
     # dims to reshape to, before broadcast
     if axis is None:
         dims = tuple(range(a.ndim))  # all axes
@@ -4714,22 +4716,6 @@ def _validate_and_ureduce_weights(a, axis, wgts):
     # Obtain a weights array of the same shape as ureduced a
     wgts = _ureduce(wgts, func=lambda x, **kwargs: x, axis=dims)
 
-    # Now check/renormalize weights if any is (0, 1)
-    def _normalize(v):
-        inds = v > 0
-        if (v[inds] < 1).any():
-            vec = v.copy()
-            vec[inds] = vec[inds] / vec[inds].min()  # renormalization
-            return vec
-        else:
-            return v
-
-    # perform normalization along reduced axis
-    if len(dims) > 1:
-        wgts = np.apply_along_axis(_normalize, -1, wgts)
-    else:
-        wgts = np.apply_along_axis(_normalize, dims[0], wgts)
-
     return wgts
 
 
@@ -5022,11 +5008,14 @@ def _get_weighted_quantile_values(arr1d, wgts1d):
 
             # each weight occupies a range in weight space w/ left/right bounds
             left_weight_bound = np.roll(wgts1d_cumsum, 1)
-            left_weight_bound[0] = 0  # left-most weight bound fixed at 0
-            right_weight_bound = wgts1d_cumsum - 1
+            # value i left weight index bound = sum(weights before i) + 1 - 1,
+            # the +1 due to neighboring values having an index distance of 1,
+            # the -1 due to 0-indexing in Python
+            left_weight_bound[0] = 0  # left-most weight bound defined to be 0
+            right_weight_bound = wgts1d_cumsum - 1  # -1 due to 0-indexing
 
             # now construct a mapping from weight bounds to real indexes
-            # for example, arr1d=[1, 2] & wgts1d=[2, 3] ->
+            # arr1d=[7, 8] & wgts1d=[2, 3] == [7, 7, 8, 8, 8]
             # -> real_indexes=[0, 0, 1, 1] & w_index_bounds=[0, 1, 2, 4]
             indexes = np.arange(arr1d.size)
             real_indexes = np.zeros(2 * indexes.size)
@@ -5039,29 +5028,35 @@ def _get_weighted_quantile_values(arr1d, wgts1d):
             # first define previous_w_indexes/next_w_indexes as the indexes
             # within w_index_bounds whose values sandwich weight_space_indexes.
             # so if w_index_bounds=[0, 1, 2, 4] and weight_space_index=3.5,
-            # then previous_w_indexes = 2 and next_w_indexes = 3
+            # then previous_w_indexes = 2 and next_w_indexes = 3,
+            # meaning weight_space_indexed is sandwiched by w_index_bounds[2]
+            # and w_index_bounds[3].
             previous_w_indexes = np.searchsorted(w_index_bounds,
                                                  weight_space_indexes,
                                                  side="right") - 1
             # leverage _get_index() to deal with out-of-bound indices
             previous_w_indexes, next_w_indexes =\
                 _get_indexes(w_index_bounds, previous_w_indexes,
                              len(w_index_bounds))
-            # now redefine previous_w_indexes/next_w_indexes as the weight
-            # space indexes that neighbor weight_space_indexes.
+            # following earlier example, we now know weight_space_indexed is
+            # sandwiched by w_index_bounds[2] and w_index_bounds[3], which are
+            # 2 and 4.  We want the 2 and 4.
+            # so redefine previous_w_indexes/next_w_indexes as the
+            # w_index_bounds that neighbor weight_space_indexes.
             previous_w_indexes = w_index_bounds[previous_w_indexes]
             next_w_indexes = w_index_bounds[next_w_indexes]
 
-            # map all weight space indexes to real indexes, then compute gamma
+            # method-dependent gammas determine interpolation scheme between
+            # neighboring values, and are computed in weight space.
+            gamma =\
+                _get_gamma(weight_space_indexes, previous_w_indexes, method)
+
+            # map all weight space indexes to real indexes
             previous_indexes =\
                 np.interp(previous_w_indexes, w_index_bounds, real_indexes)
             next_indexes =\
                 np.interp(next_w_indexes, w_index_bounds, real_indexes)
 
-            # method-dependent gammas determine interpolation scheme between
-            # neighboring values, and are computed in weight space.
-            gamma =\
-                _get_gamma(weight_space_indexes, previous_w_indexes, method)
             previous = take(arr1d, previous_indexes.astype(int))
             next = take(arr1d, next_indexes.astype(int))
             return _lerp(previous, next, gamma, out=out)
@@ -5075,7 +5070,8 @@ def _get_weighted_quantile_values(arr1d, wgts1d):
         result = get_weighted_quantile_values(arr, weights)
 
         # now move data to DATA_AXIS to be consistent with no-weights case
-        result = np.moveaxis(result, -1, destination=0)
+        if axis != -1 and quantiles.ndim:
+            result = np.moveaxis(result, -1, destination=0)
 
     else:
         values_count = arr.shape[axis]
 
@@ -1219,8 +1219,8 @@ def nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=np._NoValu
 
 
 def _nanpercentile_dispatcher(
-        a, q, axis=None, weights=None, out=None, overwrite_input=None,
-        method=None, keepdims=None, *, interpolation=None):
+        a, q, axis=None, out=None, overwrite_input=None,
+        method=None, keepdims=None, *, weights=None, interpolation=None):
     return (a, q, out)
 
 
@@ -1229,12 +1229,12 @@ def nanpercentile(
         a,
         q,
         axis=None,
-        weights=None,
         out=None,
         overwrite_input=False,
         method="linear",
         keepdims=np._NoValue,
         *,
+        weights=None,
         interpolation=None,
 ):
     """
@@ -1385,9 +1385,9 @@ def nanpercentile(
         a, q, axis, weights, out, overwrite_input, method, keepdims)
 
 
-def _nanquantile_dispatcher(a, q, axis=None, weights=None, out=None,
+def _nanquantile_dispatcher(a, q, axis=None, out=None,
                             overwrite_input=None, method=None, keepdims=None,
-                            *, interpolation=None):
+                            *, weights=None, interpolation=None):
     return (a, q, out)
 
 
@@ -1396,12 +1396,12 @@ def nanquantile(
         a,
         q,
         axis=None,
-        weights=None,
         out=None,
         overwrite_input=False,
         method="linear",
         keepdims=np._NoValue,
         *,
+        weights=None,
         interpolation=None,
 ):
     """
 
@@ -3037,10 +3037,10 @@ def test_fraction(self):
 
     def test_api(self):
         d = np.ones(5)
-        np.percentile(d, 5, None, None, None, False)
-        np.percentile(d, 5, None, None, None, False, 'linear')
+        np.percentile(d, 5, None, None, False)
+        np.percentile(d, 5, None, None, False, 'linear')
         o = np.ones((1,))
-        np.percentile(d, 5, None, None, o, False, 'linear')
+        np.percentile(d, 5, None, o, False, 'linear')
 
     def test_complex(self):
         arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='G')
@@ -3861,15 +3861,8 @@ def test_various_weights(self, method):
         assert_almost_equal(actual, expected)
 
         # mix of numeric types
-        # due to renormalization triggered by weight < 1,
         # this is expected to be the same as weights = [1, 2, 3]
-        weights = [decimal.Decimal(0.5), 1, 1.5]
-        actual = np.quantile(ar, q=q, axis=axis, weights=weights,
-                             method=method)
-        assert_almost_equal(actual, expected)
-
-        # show that normalization means sum of weights is irrelavant
-        weights = [0.1, 0.2, 0.3]
+        weights = [decimal.Decimal(1.0), 2, 3.0]
         actual = np.quantile(ar, q=q, axis=axis, weights=weights,
                              method=method)
         assert_almost_equal(actual, expected)
@@ -3882,12 +3875,6 @@ def test_various_weights(self, method):
         expected = np.quantile(ar_012, q=q, axis=axis, method=method)
         assert_almost_equal(actual, expected)
 
-        # weight entries < 1
-        weights = [0.0, 0.001, 0.002]
-        actual = np.quantile(ar, q=q, axis=axis, weights=weights,
-                             method=method)
-        assert_almost_equal(actual, expected)
-
     def test_weights_flags(self):
         """Test that flags are raised on invalid weights."""
         ar = np.arange(6).reshape(2, 3)
@@ -3902,6 +3889,8 @@ def test_weights_flags(self):
             np.quantile(ar, q=q, axis=axis, weights=[1, np.nan])
         with assert_raises_regex(ValueError, "Negative weight not allowed"):
             np.quantile(ar, q=q, axis=axis, weights=[1, -1])
+        with assert_raises_regex(ValueError, "Partial weight"):
+            np.quantile(ar, q=q, axis=axis, weights=[1, 0.1])
         with assert_raises_regex(ZeroDivisionError, "Weights sum to zero"):
             np.quantile(ar, q=q, axis=axis, weights=[0, 0])
 
 
@@ -1357,15 +1357,8 @@ def test_various_weights(self, method):
         assert_almost_equal(actual, expected)
 
         # mix of numeric types
-        # due to renormalization triggered by weight < 1,
         # this is expected to be the same as weights = [1, 2, 3]
-        weights = [decimal.Decimal(0.5), 1, 1.5]
-        actual = np.nanquantile(ar, q=q, axis=axis, weights=weights,
-                                method=method)
-        assert_almost_equal(actual, expected)
-
-        # show that normalization means sum of weights is irrelavant
-        weights = [0.2, 0.4, 0.6]
+        weights = [decimal.Decimal(1.0), 2, 3.0]
         actual = np.nanquantile(ar, q=q, axis=axis, weights=weights,
                                 method=method)
         assert_almost_equal(actual, expected)
@@ -1378,12 +1371,6 @@ def test_various_weights(self, method):
         expected = np.nanquantile(ar_012, q=q, axis=axis, method=method)
         assert_almost_equal(actual, expected)
 
-        # weight entries < 1
-        weights = [0.0, 0.001, 0.002]
-        actual = np.nanquantile(ar, q=q, axis=axis, weights=weights,
-                                method=method)
-        assert_almost_equal(actual, expected)
-
     def test_weights_flags(self):
         """Test that flags are raised on invalid weights."""
         ar = np.arange(6).reshape(2, 3).astype(float)
@@ -1399,6 +1386,8 @@ def test_weights_flags(self):
             np.quantile(ar, q=q, axis=axis, weights=[1, np.nan])
         with assert_raises_regex(ValueError, "Negative weight not allowed"):
             np.quantile(ar, q=q, axis=axis, weights=[1, -1])
+        with assert_raises_regex(ValueError, "Partial weight"):
+            np.quantile(ar, q=q, axis=axis, weights=[1, 0.1])
         with assert_raises_regex(ZeroDivisionError, "Weights sum to zero"):
             np.quantile(ar, q=q, axis=axis, weights=[0, 0])