logical-operators

As I was reading a colleague's Java code, I stumbled upon an army of if/else statements. In these statements, several && and || operators were fighting each other without any help from parenthesis. I simplified the statements into: if (true || true && false) return true; else return false; What do you think the result would be? Honestly, I thought it would be false , but it seems short-circuiting doesn't work like I expected. In this case, the result is true . The short-circuit mechanism seems to consider the whole expression as true when it finds true immediately followed by || . But in the

I'm trying to use the logical_and of two or more numpy arrays. I know numpy has the function logical_and() , but I find the simple operator & returns the same results and are potentially easier to use. For example, consider three numpy arrays a, b, and c. Is np.logical_and(a, np.logical_and(b,c)) equivalent to a & b & c ? If they are (more or less) equivalent, what's the advantage of using logical_and() ? @user1121588 answered most of this in a comment, but to answer fully... "Bitwise and" ( & ) behaves much the same as logical_and on boolean arrays, but it doesn't convey the intent as well as

I know that the result of logical operations in most of the languages is either true, false or 1,0. In Javascript I tried the following: alert(6||5) // => returns 6 alert(5||6) // => returns 5 alert(0||5) // => returns 5 alert(5||0) // => returns 5 alert(5||1) // => returns 5 alert(1||5) // => returns 1 alert(5&&6) // => returns 6 alert(6&&5) // => returns 5 alert(0&&5) // => returns 0 alert(5&&0) // => returns 0 alert(-1&&5) // => returns 5 alert(5&&-1) // => returns -1 So what is the result of logical operators? If one operand is 0 or 1 then it works as expected. If both are nonzero and

There's a bunch out there, as Perl is a pretty sugary language, but the most used statements in any language is the combination of if statements and setting values. I think I've found many of them, but there's still a few gaps. Ultimately, the goal would be to not have to write a variable name more than once: Here's what I have so far: $r ||= $s; # $r = $s unless ($r); $r //= $s; # $r = $s unless (defined $r); $r &&= $s; # $r = $s if ($r); $r = $c ? $s : $t; # if ($c) { $r = $s } else { $r = $t } $c ? $r : $s = $t; # if ($c) { $r = $t } else { $s = $t } $r = $s || $t; # if ($s) { $r = $s }

I'm working with Ruby on Rails and would like to validate two different models : if (model1.valid? && model2.valid?) ... end However, "&&" operator uses short-circuit evaluation (i.e. it evaluates "model2.valid?" only if "model1.valid?" is true), which prevents model2.valids to be executed if model1 is not valid. Is there an equivalent of "&&" which would not use short-circuit evaluation? I need the two expressions to be evaluated. Try this: ([model1, model2].map(&:valid?)).all? It'll return true if both are valid, and create the errors on both instances. & works just fine. irb(main):007:0>

I read some legacy code: if ( 1 || !Foo() ) Is there any seen reason why not to write: if ( !Foo() ) The two are not the same. The first will never evaluate Foo() because the 1 short-circuits the || . Why it's done - probably someone wanted to force entry in the then branch for debugging purposes and left it there. It could also be that this was written before source control, so they didn't want the code to be lost, rather just bypassed for now . if (1 || !Foo() ) will be always satisfied. !Foo() will not even be reached because of short-circuits evaluation . This happens when you want to make