I agree. Not only is it duplicative but also the fix implementation is inefficient:

In [4]: arr = np.random.random(1_000_000)*1000
In [5]: %timeit np.trunc(arr)
426 μs ± 15.1 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

In [6]: %timeit np.fix(arr)
1.06 ms ± 3.34 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
In [7]: np.all(np.trunc(arr) == np.fix(arr))
Out[7]: np.True_

The array API also defines trunc: https://data-apis.org/array-api/2024.12/API_specification/generated/array_api.trunc.html

Not fix though: https://data-apis.org/array-api/2024.12/search.html?q=fix

There's a lot of open source uses of np.fix so this will have to be a slow deprecation: https://github.com/search?q=np.fix+language%3APython&type=code&l=Python.

Here is the implementation of np.fix, it's all in Python so this should be a relatively easy project for an interested contributor:

numpy/numpy/lib/_ufunclike_impl.py

Lines 16 to 67 in fb55b5b

    
           @array_function_dispatch(_dispatcher, verify=False, module='numpy') 
        
           def fix(x, out=None): 
        
               """ 
        
               Round to nearest integer towards zero. 
        
               Round an array of floats element-wise to nearest integer towards zero. 
        
               The rounded values have the same data-type as the input. 
        
               Parameters 
        
               ---------- 
        
               x : array_like 
        
                   An array to be rounded 
        
               out : ndarray, optional 
        
                   A location into which the result is stored. If provided, it must have 
        
                   a shape that the input broadcasts to. If not provided or None, a 
        
                   freshly-allocated array is returned. 
        
               Returns 
        
               ------- 
        
               out : ndarray of floats 
        
                   An array with the same dimensions and data-type as the input. 
        
                   If second argument is not supplied then a new array is returned 
        
                   with the rounded values. 
        
                   If a second argument is supplied the result is stored there. 
        
                   The return value ``out`` is then a reference to that array. 
        
               See Also 
        
               -------- 
        
               rint, trunc, floor, ceil 
        
               around : Round to given number of decimals 
        
               Examples 
        
               -------- 
        
               >>> import numpy as np 
        
               >>> np.fix(3.14) 
        
               3.0 
        
               >>> np.fix(3) 
        
               3 
        
               >>> np.fix([2.1, 2.9, -2.1, -2.9]) 
        
               array([ 2.,  2., -2., -2.]) 
        
               """ 
        
               # promote back to an array if flattened 
        
               res = nx.ceil(x, out=... if out is None else out) 
        
               res = nx.floor(x, out=res, where=nx.greater_equal(x, 0)) 
        
               # when no out argument is passed and no subclasses are involved, flatten 
        
               # scalars 
        
               if out is None and type(res) is nx.ndarray: 
        
                   res = res[()] 
        
               return res

	@array_function_dispatch(_dispatcher, verify=False, module='numpy')
	def fix(x, out=None):
	"""
	Round to nearest integer towards zero.

	Round an array of floats element-wise to nearest integer towards zero.
	The rounded values have the same data-type as the input.

	Parameters
	----------
	x : array_like
	An array to be rounded
	out : ndarray, optional
	A location into which the result is stored. If provided, it must have
	a shape that the input broadcasts to. If not provided or None, a
	freshly-allocated array is returned.

	Returns
	-------
	out : ndarray of floats
	An array with the same dimensions and data-type as the input.
	If second argument is not supplied then a new array is returned
	with the rounded values.

	If a second argument is supplied the result is stored there.
	The return value ``out`` is then a reference to that array.

	See Also
	--------
	rint, trunc, floor, ceil
	around : Round to given number of decimals

	Examples
	--------
	>>> import numpy as np
	>>> np.fix(3.14)
	3.0
	>>> np.fix(3)
	3
	>>> np.fix([2.1, 2.9, -2.1, -2.9])
	array([ 2., 2., -2., -2.])

	"""
	# promote back to an array if flattened
	res = nx.ceil(x, out=... if out is None else out)
	res = nx.floor(x, out=res, where=nx.greater_equal(x, 0))

	# when no out argument is passed and no subclasses are involved, flatten
	# scalars
	if out is None and type(res) is nx.ndarray:
	res = res[()]
	return res

Uh oh!

DEP: Deprecate np.fix #30096

Description

Issue with current documentation:

Idea or request for content:

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions