[Numpy-discussion] logical priority

[Mark Histed]

> Anyway, we've wandered afar from the main point:  what is the best way 
> to duplicate the functionality of the following MATLAB snippet:
> 
> f = ~isnan(data1) & ~isnan(data2);
> plot(x,data1(f),x,data2(f))

I know this has been talked about before on this list, but only in
bits and pieces.  Can I summarize the way I understand the situation
and hopefully others can correct me?  I use MATLAB and Numeric often;
I have rarely used Numarray.

Summary:

For people moving from Matlab to Numeric/Numarray, the recommendation
is to use Numeric's "&" in place of Matlab's "&" to combine logical
arrays for indexing.  Different behavior results if the inputs have
entries > 1, and you have to put parenthesis around any inputs that
use relational operators.
Also, one should use Numeric's "and" in place of Matlab's "&&".

Details:

In MATLAB (R14SP1) there are three logical "and" operators:

"&": a binary operator which performs element-by-element logical AND.
    For its purposes, 0 is FALSE and every other numerical value is TRUE.
"&&": a binary operator which performs logical AND, but does
    short-circuiting, and only works with scalar elements (length-1 arrays)
"bitand()" : a function which takes two integers and does bitwise-and
    on their binary representations

http://www.mathworks.com/access/helpdesk/help/techdoc/matlab_prog/ch12_n11.html#38948

I think that these map onto the python operators in the following way:
MATLAB      Python/Numeric
------      --------------
&&          and
&           ufunc logical_and()
bitand      &

Some inconsistencies in behavior (between Numeric and Matlab) occur
when one uses Numeric's "&" like MATLAB "&".  I can think of:
    * Non-logical {0,1} inputs: Numeric's output is an integer, the
      bitwise and of the inputs, Matlab's output is a logical array,
      either 1 or 0. 
    * Precedence: Numeric's "&" operator is higher prec than its relational
      operators, MATLAB is the reverse

And an inconsistency between MATLAB's "&&" and Numeric's "and":
    * MATLAB returns an error when the arguments to && are not logical
      scalars, Numeric returns the second argument as the expression's
      value. (but Numarray behaves like MATLAB)



Does that seem right?  

Regards, 
Mark

    
  
----------------------------------------------------------------

Matlab example:

>> a = [0,1,2];
>> b = [1,1,63];
>> a & b
ans =
     0     1     1
>> a && b
??? Operands to the || and && operators must be convertible to logical 
    scalar values.
>> bitand(a,b)
ans =
     0     1     2
>> a > 1 & b > 1
ans =
     0     0     1
>> (a > 1) & (b > 1)
ans =
     0     0     1

----------------------------------------------------------------

Numeric example:

Python 2.3.4 (#2, Sep 24 2004, 08:39:09)
[GCC 3.3.4 (Debian 1:3.3.4-12)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import Numeric as N
>>> a = N.array([0,1,2]);
>>> b = N.array([1,1,63]);
>>> N.logical_and(a,b)
array([0, 1, 1])
>>> a & b
array([0, 1, 2])
>>> a and b
array([ 1,  1, 63])
>>> a > 1 & b > 1
array([0, 0, 0])
>>> (a > 1) & (b > 1)
array([0, 0, 1])

----------------------------------------------------------------

Numarray example:
>>> import numarray as na
>>> a = na.array([0,1,2])
>>> b = na.array([1,1,63])
>>> na.logical_and(a,b)
array([0, 1, 1], type=Bool)
>>> a and b
RuntimeError: An array doesn't make sense as a truth value.  Use
    sometrue(a) or alltrue(a). 
>>> a & b
array([0, 1, 2])
>>>

----------------------------------------------------------------

On Wed, Feb 09, 2005 at 10:11:56AM -0800, Stephen Walton wrote:
> Fernando Perez wrote a good deal clarifying how Python's logical 
> operators work, for which I'm grateful.  One brief comment:
> 
> >Bytecode analysis can be really useful to understand this kind of 
> >subtle issues.  I can't think of any language where this approach is 
> >as easy to do and friendly as in python.
> 
> Pardon me, but this sounds a bit like looking at the assembly language 
> Fortran generates in order to understand the subtleties of that language 
> :-) .  I know people who used to do that, and were proud of it, but I'd 
> rather the language itself didn't behave in surprising ways.  At least 
> in Fortran, 'a .and. b' only made sense if a and b were both of type 
> LOGICAL;  in fact, it was a compile time error if they weren't.
> 

> 
> ?
> 
> 
> 
> SF email is sponsored by - The IT Product Guide
> Read honest & candid reviews on hundreds of IT Products from real users.
> Discover which products truly live up to the hype. Start reading now.
> http://ads.osdn.com/?ad_id=6595&alloc_id=14396&op=click
> _______________________________________________
> Numpy-discussion mailing list
> Numpy-discussion at lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/numpy-discussion