[Numpy-discussion] short circuit != ?

[Lluís]

Alan G Isaac writes:

> Maybe:
> any((ai != bi) for ai,bi in izip(a.flat,b.flat))
> ?

I think this would indeed work, but it's not really friendly, while it
should work out-of-the-box.

Of course, we do not always want operations to perform lazily, so a
generic approach might be on the lines of:

  any(a.lazy() != b)

Invoking 'lazy' on an ndarray would return an object that instead of
computing the given operations will just record them, and try to defer
their evaluation as much as possible.

E.g.,:

  class LazyNdarray:

        def __init__ (self, left, op = None, right = None):
            self._left = left
            self._op = op
            self._right = right

        # transitivize deferral on these operations

        def __neq__ (self, other):
            return LazyNdarray(self, "__neq__", other)

        # evaluate on these operations

        def __getitem__ (self, index):
            return self._evaluate(index)

        def __iter__ (self):
            for idx in range(len(self._left)):
                yield self._evaluate(idx)

        # do the evaluation

        def _evaluate (self, index)
            # still, this will not work unles no broadcast is necessary
            l = self._left[index]
            op = getattr(l, self._op)
            return op(right[index])

  class ndarray:
        def lazy (self):
            return LazyNdarray(self)

Or something like that.

Lluis

-- 
 "And it's much the same thing with knowledge, for whenever you learn
 something new, the whole world becomes that much richer."
 -- The Princess of Pure Reason, as told by Norton Juster in The Phantom
 Tollbooth