[Numpy-discussion] ndarray.fill and ma.array.filled
tim.hochberg at cox.net
Thu Mar 23 08:12:09 CST 2006
Fernando Perez wrote:
> Tim Hochberg wrote:
>> My opinion is that all methods and functions should either:
>> 1. Always return a copy.
>> 2. Always return a view
>> 3. Return a view if possible otherwise raise an exception.
> Well, but is copy/view the /only/ invariant worth guaranteeing? I
> think there is a valid need for functions which ensure other
> invariants, such as contiguity. There are applications (such as
> passing pointers to C/Fortran libraries which don't have striding
> mechanisms but will not modify their inputs) which require contiguous
> inputs, but where one would rather make a copy only if necessary.
This is a different case, I think. The result of this copy is not user
visible except in terms of performance. I'm only concerned with
functions that *return* copies or views depending on the input. I don't
care if a function sometimes makes a copy under the covers but doesn't
> My take on this is that we should /document/ clearly what invariants
> any given function satisfies, but I think the 'always view/always
> copy' view excludes an important usage case. There may be others
> beyond contiguity, but that's the one that pops immediately to mind.
I don't think we're in disagreement here although I'm not sure.
I will add, on the subject of continuity, that I think there should be a
function 'ascontiguous' that parallels asarray, but assures that the
result is contiguous. Although this sometimes returns a copy, I thinks
that's OK since that's it's job. I would like to see all of the implicit
copying pushed into functions like asarray and ascontiguous.
This also helps efficiency. Imagine I have some calls to functions that
require contiguous arrays and do copies under the covers if their args
are not contiguous. In that case:
a = ascontiguous(a)
param1 = computeSomethingOnContiguousData(a)
param2 = computeSomethingElseOnContiguousData(a)
Will be much more efficient than the equivalent code without the
ascontiguous when the initial a value is not discontiguous.
More information about the Numpy-discussion