[Numpy-discussion] Response to PEP suggestions

konrad.hinsen at laposte.net konrad.hinsen at laposte.net
Fri Feb 18 06:31:17 CST 2005

On Feb 17, 2005, at 23:22, Duncan Child wrote:

> I have attached some code that illustrates part of the pain we have 
> experienced developing libraries of algorithms that can handle both 
> arrays and scalars. The attached library is the reusable part. The 
> other part of this problem is that we have lots of logic sprinkled 
> throughout our algorithms to enable them to handle both arrays and 
> scalars.

See comments below...

> Secondly, I have just been bitten by this declaration which suggests 
> that the new Numeric might handle default values better:.
> _vp_mod = zeros(num_pts)
> It would be less surprising to someone developing numeric algorithms 
> if functions like this defaulted to creating a double precision array 
> rather than integers.

If you want a function that returns float arrays, it is trivial to 
write and adds negligible overhead:

	def float_array(array_spec):
		return Numeric.array(array_spec, Numeric.Float)

No need to interfere with Numeric's principle of "smallest usable 
type", which fits well into the Python type promotion hierarchy.

More generally, I don't think defaults should be chosen with a 
particular application in mind. Arrays are a general and widely useful 
datatype in many domains. I use integer arrays as much as float arrays, 
even though my applications qualify as "numeric".

> """
> The following safe_ methods were written to handle both arrays amd 
> scalars to
> save the developer of numerical methods having to clutter their code 
> with tests
> to determine the type of the data.
> """
> def safe_take(a,indices):
>    # Slice the input if it is an array but not if it is a scalar

This is a very bad example. Your function does not interpret scalars as 
rank-0 arrays (for which take() would fail), but as something 
completely different.

>   def safe_copy(a):
>    # Return a copy for both scalar and array input

That is a semantically reasonable application, but also one for which a 
simple and standard solution already exists: copy.copy().

> def safe_min(a):
>    # Return the minimum of the input array or the input if it is a 
> scalar

I would argue that this is not a good example either, as "minimum over 
an array" implies a reduction operation which is not defined for a 
scalar. On the other hand, the operation you define certainly makes 

> def safe_len(a):
>    # Return the length of the input array or 1 if it is a scalar

That implies that a scalar is somehow equivalent to a rank-1 array of 
length 1, which is not the case.

Actually, all of your examples look like an attempt to recreate Matlab 
behaviour. But Python is not Matlab!

Konrad Hinsen
Laboratoire Léon Brillouin, CEA Saclay,
91191 Gif-sur-Yvette Cedex, France
Tel.: +33-1 69 08 79 25
Fax: +33-1 69 08 82 61
E-Mail: hinsen at llb.saclay.cea.fr

More information about the Numpy-discussion mailing list