You are actually doing this:

    var_dump(0b10 &amp; (0b01 == 0));
    var_dump(0b10 &amp; (0b01 != 0));


Try:

    var_dump((0b10 &amp; 0b01) == 0);
    var_dump((0b10 &amp; 0b01) != 0);


I have several methods annotated with `@Scheduled(fixedDelay=10000)`.

In the application context, I have this annotation-driven setup:

    &lt;task:annotation-driven /&gt;

The problem is, sometimes some of the method executions get delayed by seconds and even minutes.

I&#39;m assuming that even if a method takes a while to finish executing, the other methods would still execute. So I don&#39;t understand the delay.  

Is there a way to maybe lessen or even remove the delay?

Does spring @Scheduled annotated methods runs on different threads?

I have two strings like

    string1=&quot;abc def ghi&quot;

and

    string2=&quot;def ghi abc&quot;

How to get that this two string are same without breaking the words?

How do I compare two strings in python if order does not matter?

I&#39;ve come across a (seemingly) very strange case.

Take the number 2 (`0b10`) and bitmask it with 1 (`0b01`)

This should produce `0b00` which is equivalent to 0.

However, here&#39;s where Mr Schr&#246;dinger comes in:

    var_dump(0b10 &amp; 0b01); // int(0)
    var_dump(0b10 &amp; 0b01 == 0); // int(0)
    var_dump(0b10 &amp; 0b01 != 0); // int(0)

Whiskey. Tango. Foxtrot.

I am, admittedly, not the sharpest when it comes to bitwise operators - so maybe I&#39;ve got horribly, horribly wrong somewhere?

However, in Python:

`0b10 &amp; 0b01 == 0` = `True`

`0b10 &amp; 0b01 != 0` = `False`

...so?

Precedence and bitmask operations

I've come across a (seemingly) very strange case.
Take the number 2 (<code>0b10</code>) and bitmask it with 1 (<code>0b01</code>)
This should produce <code>0b00</code> which is equivalent to 0.
However, here's where Mr Schrödinger comes in:
<pre><code class="hljs language-scss">var_dump(0b10 &#x26; 0b01); // int(0)
var_dump(0b10 &#x26; 0b01 == 0); // int(0)
var_dump(0b10 &#x26; 0b01 != 0); // int(0)
</code></pre>
Whiskey. Tango. Foxtrot.
I am, admittedly, not the sharpest when it comes to bitwise operators - so maybe I've got horribly, horribly wrong somewhere?
However, in Python:
<code>0b10 &#x26; 0b01 == 0</code> = <code>True</code>
<code>0b10 &#x26; 0b01 != 0</code> = <code>False</code>
...so?

Can someone suggest me how can I replace the below code?

How do I rewrite the code in order to avoid the repetition of the block ` case 3:{code block A; break;}`?

    switch(i) {
      case 1:  {code block A; break;}

      case 2:  {code block b; break;}

      case 3:  {code block A; break;}

      default: {code block default; break;}
    }

How can I have combined code for case 1 and case 3?





Switch multiple case statement

I know in Python and other languages we have access to tuples to better facilitate, semantically or otherwise, the structuring of data.

My question is: Does PHP have tuples?

If not, what is the nearest facility?

Are there tuples in PHP?

I&#39;ve build a php/mysql (wamp) application and deployed on a local workstation.
My customer wants to save db and restore it when he likes.

I&#39;ve found this code for saving:

    &lt;?php
    
    
    $DB_HOST = &quot;localhost&quot;;
    $DB_USER = &quot;root&quot;;
    $DB_PASS = &quot;admin&quot;;
    $DB_NAME = &quot;dbname&quot;;
    
    $con = new mysqli($DB_HOST, $DB_USER, $DB_PASS, $DB_NAME);
    
     
     $tables = array();
    
    $result = mysqli_query($con,&quot;SHOW TABLES&quot;);
    while ($row = mysqli_fetch_row($result)) {
    	$tables[] = $row[0];
    }
    
    $return = &#39;&#39;;
    
    foreach ($tables as $table) {
    	$result = mysqli_query($con, &quot;SELECT * FROM &quot;.$table);
    	$num_fields = mysqli_num_fields($result);
    
    	$return .= &#39;DROP TABLE &#39;.$table.&#39;;&#39;;
    	$row2 = mysqli_fetch_row(mysqli_query($con, &#39;SHOW CREATE TABLE &#39;.$table));
    	$return .= &quot;\n\n&quot;.$row2[1].&quot;;\n\n&quot;;
    
    	for ($i=0; $i &lt; $num_fields; $i++) { 
    		while ($row = mysqli_fetch_row($result)) {
    			$return .= &#39;INSERT INTO &#39;.$table.&#39; VALUES(&#39;;
    			for ($j=0; $j &lt; $num_fields; $j++) { 
    				$row[$j] = addslashes($row[$j]);
    				if (isset($row[$j])) {
    					$return .= &#39;&quot;&#39;.$row[$j].&#39;&quot;&#39;;} else { $return .= &#39;&quot;&quot;&#39;;}
    					if($j&lt;$num_fields-1){ $return .= &#39;,&#39;; }
    				}
    				$return .= &quot;);\n&quot;;
    			}
    		}
    		$return .= &quot;\n\n\n&quot;;
    	
    }
    
    
    $handle = fopen(&#39;backup.sql&#39;, &#39;w+&#39;);
    fwrite($handle, $return);
    fclose($handle);
    
    echo &quot;success&quot;;
    
    ?&gt;

This code saves file in a default folder.
What I need is to let user to decide **where** to save backup file or simply **download** it through browser. 
On the other hand user needs to restore from the file he wants so I need a &#39;browse&#39; button to let him choose the file in any of his folder.

My database is utf8_general_ci and has english, french and italian language I don&#39;t need complex codes because I wouldn&#39;t know how to manage them :-(

Thanks in advance.




Export MySQL database using PHP

Does anybody know the correct way to `post` JSON using `Guzzle`?

    $request = $this-&gt;client-&gt;post(self::URL_REGISTER,array(
    				&#39;content-type&#39; =&gt; &#39;application/json&#39;
    		),array(json_encode($_POST)));

I get an `internal server error` response from the server. It works using Chrome `Postman`.

How can I use Guzzle to send a POST request in JSON?

When I went through Laravel Document about Eloquent ORM topic part, I got a new term &quot;Mass Assignment&quot;.

Document show How to do Mass Assignment and the `$fillable` or `$guarded` properties settings. But after went through that, I didn&#39;t have a clearly understand about &quot;Mass Assignment&quot; and how it works.

In my past experience in CodeIgniter, I also didn&#39;t hear about this term.

Does anyone have a simple explanation about that?

What does &quot;Mass Assignment&quot; mean in Laravel?

**What explains the difference in behavior of boolean and bitwise operations on lists vs NumPy arrays?** 

I&#39;m confused about the appropriate use of `&amp;` vs `and` in Python, illustrated in the following examples.

    mylist1 = [True,  True,  True, False,  True]
    mylist2 = [False, True, False,  True, False]
    
    &gt;&gt;&gt; len(mylist1) == len(mylist2)
    True
    
    # ---- Example 1 ----
    &gt;&gt;&gt; mylist1 and mylist2
    [False, True, False, True, False]
    # I would have expected [False, True, False, False, False]
    
    # ---- Example 2 ----
    &gt;&gt;&gt; mylist1 &amp; mylist2
    TypeError: unsupported operand type(s) for &amp;: &#39;list&#39; and &#39;list&#39;
    # Why not just like example 1?

    &gt;&gt;&gt; import numpy as np

    # ---- Example 3 ----
    &gt;&gt;&gt; np.array(mylist1) and np.array(mylist2)
    ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
    # Why not just like Example 4?
    
    # ---- Example 4 ----
    &gt;&gt;&gt; np.array(mylist1) &amp; np.array(mylist2)
    array([False,  True, False, False, False], dtype=bool)
    # This is the output I was expecting!

[This answer][1] and [this answer][2] helped me understand that [`and`][3] is a boolean operation but [`&amp;`][4] is a bitwise operation. 

I read about [bitwise operations][5] to better understand the concept, but I am struggling to use that information to make sense of my above 4 examples.

Example 4 led me to my desired output, so that is fine, but I am still confused about when/how/why I should use `and` vs `&amp;`. Why do lists and NumPy arrays behave differently with these operators? 

**Can anyone help me understand the difference between boolean and bitwise operations to explain why they handle lists and NumPy arrays differently?**  


  [1]: https://stackoverflow.com/a/6490106/2098573
  [2]: https://stackoverflow.com/a/10246441/2098573
  [3]: http://docs.python.org/2/library/stdtypes.html#boolean-operations-and-or-not
  [4]: http://docs.python.org/3/reference/expressions.html#binary-bitwise-operations
  [5]: https://wiki.python.org/moin/BitwiseOperators

&#39;and&#39; (boolean) vs &#39;&amp;&#39; (bitwise) - Why difference in behavior with lists vs numpy arrays?

**Edit:** So basically what I&#39;m trying to write is a 1 bit hash for `double`.

I want to map a `double` to `true` or `false` with a 50/50 chance. For that I wrote code that picks some random numbers *(just as an example, I want to use this on data with regularities and still get a 50/50 result)*, checks their last bit and increments `y` if it is 1, or `n` if it is 0. 

However, this code constantly results in 25% `y` and 75% `n`. Why is it not 50/50? And why such a weird, but straight-forward (1/3) distribution?

    public class DoubleToBoolean {
    	@Test
    	public void test() {
    
    		int y = 0;
    		int n = 0;
    		Random r = new Random();
    		for (int i = 0; i &lt; 1000000; i++) {
    			double randomValue = r.nextDouble();
    			long lastBit = Double.doubleToLongBits(randomValue) &amp; 1;
    			if (lastBit == 1) {
    				y++;
    			} else {
    				n++;
    			}
    		}
    		System.out.println(y + &quot; &quot; + n);
    	}
    }

Example output:

    250167 749833

Why does this random value have a 25/75 distribution instead of 50/50?

I had been studying the algorithm for finding lonely integers in an array, and here is the implementation:

	int arr[] = {10, 20, 30, 5, 20, 10, 30};
    int LonelyInteger = 0;
    for(int i=0; i&lt; 7; i++)
    {
        LonelyInteger = LonelyInteger ^ arr[i];
    }

The result is `5`.

My question is - supposedly the integers (getting generated by the `XOR` operation) are **too large** due to this operation:

    LonelyInteger ^ arr[i]

Which leads to a potentially large integer which cannot be represented by the datatype say `int` in this case. My questions are:

1. Is it even possible that `XOR` will generate such a large integer value that cannot be stored in the `int` type?
2. If it is not possible that this can happen then is there a proof for this?


Can XOR of two integers go out of bounds?

When browsing the source code of Guava, I came across the following piece of code (part of the implementation of `hashCode` for the inner class `CartesianSet`):

    int adjust = size() - 1;
    for (int i = 0; i &lt; axes.size(); i++) {
        adjust *= 31;
        adjust = ~~adjust;
        // in GWT, we have to deal with integer overflow carefully
    }
    int hash = 1;
    for (Set&lt;E&gt; axis : axes) {
        hash = 31 * hash + (size() / axis.size() * axis.hashCode());

        hash = ~~hash;
    }
    hash += adjust;
    return ~~hash;

Both of `adjust` and `hash` are `int`s. From what I know about Java, `~` means bitwise negation, so `adjust = ~~adjust` and `hash = ~~hash` should leave the variables unchanged. Running the small test (with assertions enabled, of course),

    for (int i = Integer.MIN_VALUE; i &lt; Integer.MAX_VALUE; i++) {
        assert i == ~~i;
    }

confirms this. Assuming that the Guava guys know what they are doing, there must be a reason for them to do this. The question is what?

**EDIT** As pointed out in the comments, the test above doesn&#39;t include the case where `i` equals `Integer.MAX_VALUE`. Since `i &lt;= Integer.MAX_VALUE` is always true, we will need to check that case outside the loop to prevent it from looping forever. However, the line

    assert Integer.MAX_VALUE == ~~Integer.MAX_VALUE;

yields the compiler warning &quot;Comparing identical expressions&quot;, which pretty much nails it.

What is the meaning of double tilde (~~) in Java?

Imagine I have two unsigned bytes `b` and `x`. I need to calculate `bsub` as `b - x` and `badd` as `b + x`. However, I don&#39;t want underflow/overflow occur during these operations. For example (pseudo-code):

    b = 3; x = 5;
    bsub = b - x; // bsub must be 0, not 254
and

    b = 250; x = 10;
    badd = b + x; // badd must be 255, not 4

The obvious way to do this includes branching:

    bsub = b - min(b, x);
    badd = b + min(255 - b, x);

I just wonder if there are any better ways to do this, i.e. by some hacky bit manipulations?

Saturating subtract/add for unsigned bytes

In Apple&#39;s documentation about interacting with C APIs, they describe the way `NS_ENUM`-marked C-style enumerations are imported as Swift enumerations. This makes sense, and since enumerations in Swift are readily provided as the `enum` value type it&#39;s easy to see how to create our own.

Further down, it says this about `NS_OPTIONS`-marked C-style options:

&gt; Swift also imports options marked with the `NS_OPTIONS` macro. Whereas
&gt; options behave similarly to imported enumerations, options can also
&gt; support some bitwise operations, such as `&amp;`, `|`, and `~`. In Objective-C,
&gt; you represent an empty option set with the constant zero (`0`). In
&gt; Swift, use `nil` to represent the absence of any options.

Given that there isn&#39;t an `options` value type in Swift, how can we create a C-Style options variable to work with?

How to create NS_OPTIONS-style bitmask enumerations in Swift?

I was reading a chapter on bitwise operators, I came across 1&#39;s complement operator program and decided to run it on Visual C++.

    int main ()
    {
       unsigned char c = 4, d;
       d = ~c;
       printf(&quot;%d\n&quot;, d);
    }

It gives the valid output: `251`

Then instead of using `d` as a variable to hold the value of `~c`, I decided to directly print the value of `~c`.

    int main ()
    {
       unsigned char c=4;
       printf(&quot;%d\n&quot;, ~c);
    }

It gives the output `-5`.

Why didn&#39;t it work?

Why does the complement behave differently through printf?

What does &#39;x &lt;&lt; ~y&#39; represent in JavaScript?

I understand that the bitwise `SHIFT` operation does this:

&lt;pre&gt;x &amp;lt;&amp;lt; y AS x * 2&lt;sup&gt;y&lt;/sup&gt;&lt;/pre&gt;

And a tilde `~` operator does:

    ~x AS -(x+1)

So, I assume the following:

&lt;pre&gt;5 &amp;lt;&amp;lt; ~3 AS 5 * 2&lt;sup&gt;-4&lt;/sup&gt; or 5 * Math.pow(2, -4)&lt;/pre&gt;

It should result in `0.3125`.

But, when I run `5 &lt;&lt; ~3` it results in `1342177280`.

What is a step-by-step explanation? How and why does this combination of operations result in `1342177280` instead of `0.3125`?

&lt;sub&gt;(This question is similar to Stack&amp;nbsp;Overflow question *[What are bitwise operators?][1]* about the bitwise `SHIFT` operator.)&lt;/sub&gt;

  [1]: https://stackoverflow.com/questions/276706/what-are-bitwise-operators


What does &#39;x &lt;&lt; ~y&#39; represent in JavaScript?

When understanding how primitive operators such as `+`, `-`, `*` and `/` are implemented in C, I found the following snippet from [an interesting answer][1].

    // replaces the + operator
    int add(int x, int y) {
        while(x) {
            int t = (x &amp; y) &lt;&lt;1;
            y ^= x;
            x = t;
        }
        return y;
    }

It seems that this function demonstrates how `+` actually works in the background. However, it&#39;s too confusing for me to understand it. I believed that such operations are done using assembly directives generated by the compiler for a long time!

Is the `+` operator implemented as the code posted on **MOST** implementations? Does this take advantage of two&#39;s complement or other implementation-dependent features?

  [1]: https://stackoverflow.com/a/11694778/5399734

Is this how the + operator is implemented in C?

What is the predefined order in which the clauses are executed in MySQL? Is some of it decided at run time, and is this order correct?

 - `FROM clause`
 - `WHERE clause` 
 - `GROUP BY clause`
 - `HAVING clause` 
 - `SELECT clause` 
 - `ORDER BY clause`

MySQL query / clause execution order

I tried the following code in Java

    t1 = 5;
    t2 = t1 + (++t1);
    System.out.println (t2);

My view is since ++ has a higher precedence than +, the above becomes

    t2 = t1 + (++t1);
    t2 = t1 + 6;      // t1 becomes 6 here
    t2 = 6 + 6;
    t2 = 12;

However, I get the answer 11 for t2. Can someone explain?



In Java, which gets executed first, &quot;+&quot; or &quot;++&quot;?

In Bjarne Stroustrup&#39;s *[The C++ Programming Language][1]* 4th edition section `36.3.6` *STL-like Operations* the following code is used as an example of [chaining](http://en.wikipedia.org/wiki/Method_chaining):

    void f2()
    {
        std::string s = &quot;but I have heard it works even if you don&#39;t believe in it&quot; ;
        s.replace(0, 4, &quot;&quot; ).replace( s.find( &quot;even&quot; ), 4, &quot;only&quot; )
            .replace( s.find( &quot; don&#39;t&quot; ), 6, &quot;&quot; );

        assert( s == &quot;I have heard it works only if you believe in it&quot; ) ;
    }

The assert fails in `gcc` (*[see it live](http://coliru.stacked-crooked.com/a/d3d81ff98cab2f5c)*) and `Visual Studio` (*[see it live](http://rextester.com/IFNX5880)*), but it does not fail when using [Clang][2] (*[see it live](http://coliru.stacked-crooked.com/a/e6facaa9f18e252f)*).

Why am I getting different results? Are any of these compilers incorrectly evaluating the chaining expression or does this code exhibit some form of [unspecified](http://en.wikipedia.org/wiki/Unspecified_behavior) or [undefined behavior](http://en.wikipedia.org/wiki/Undefined_behavior)?

  [1]: https://en.wikipedia.org/wiki/The_C%2B%2B_Programming_Language
  [2]: http://en.wikipedia.org/wiki/Clang


Does this code from &quot;The C++ Programming Language&quot; 4th edition section 36.3.6 have well-defined behavior?

If I do this:

    &gt;&gt;&gt; False in [False, True]
    True

That returns `True`. Simply because `False` is in the list.

But if I do:

    &gt;&gt;&gt; not(True) in [False, True]
    False

That returns `False`. Whereas `not(True)` is equal to `False`:

    &gt;&gt;&gt; not(True)
    False

Why?


Why does &quot;not(True) in [False, True]&quot; return False?

The output of this program:

    #include &lt;iostream&gt; 
    class c1
    {   
      public:
        c1&amp; meth1(int* ar) {
          std::cout &lt;&lt; &quot;method 1&quot; &lt;&lt; std::endl;
          *ar = 1;
          return *this;
        }
        void meth2(int ar)
        {
          std::cout &lt;&lt; &quot;method 2:&quot;&lt;&lt; ar &lt;&lt; std::endl;
        }
    };

    int main()
    {
      c1 c;
      int nu = 0;
      c.meth1(&amp;nu).meth2(nu);
    }

Is:

    method 1
    method 2:0

Why is `nu` not 1 when `meth2()` starts?

Content Type	Original Author	Original Content on Stackoverflow
Question	Danny Kopping	View Question on Stackoverflow
Solution 1 - Php	Matthew	View Answer on Stackoverflow

Precedence and bitmask operations

Php Problem Overview

Php Solutions

Solution 1 - Php

How do I compare two strings in python if order does not matter?

Does spring @Scheduled annotated methods runs on different threads?

Attributions