The magic number is supposed to be 32 random bits, where each is equally likely to be 0 or 1, and with no simple correlation between the bits. A common way to find a string of such bits is to use the binary expansion of an irrational number; in this case, that number is the reciprocal of the golden ratio:

    phi = (1 + sqrt(5)) / 2
    2^32 / phi = 0x9e3779b9

So including this number &quot;randomly&quot; changes each bit of the seed; as you say, this means that consecutive values will be far apart. Including the shifted versions of the old seed makes sure that, even if `hash_value()` has a fairly small range of values, differences will soon be spread across all the bits.

Take a look at the [DDJ article by Bob Jenkins from 1997][1]. The magic constant (&quot;golden ratio&quot;) is explained as follows:

&gt; The golden ratio really is an arbitrary value. Its purpose is to avoid mapping all zeros to all zeros.

  [1]: http://burtleburtle.net/bob/hash/doobs.html

I&#39;d like Jackson to deserialize a class with the following constructor:

    public Clinic(String name, Address address)

Deserializing the first argument is easy. The problem is that Address is defined as:

    public class Address {
      private Address(Map&lt;LocationType, String&gt; components)
      ...
    
      public static class Builder {
        public Builder setCity(String value);
        public Builder setCountry(String value);
        public Address create();
      }
    }

and is constructed like this: `new Address.Builder().setCity(&quot;foo&quot;).setCountry(&quot;bar&quot;).create();`

Is there a way to get key-value pairs from Jackson in order to construct the Address myself? Alternatively, is there a way to get Jackson to use the Builder class itself?

Jackson + Builder Pattern?

in Javascript I can&#39;t seem to find a method to set negatives to zero?

-90 becomes 0&lt;br /&gt;
-45 becomes 0&lt;br /&gt;
0 becomes 0&lt;br /&gt;
90 becomes 90&lt;br /&gt;

Is there anything like that? I have just rounded numbers.

Javascript Math Object Methods - negatives to zero

The `boost::hash_combine` template function takes a reference to a hash (called `seed`) and an object `v`. According to the [docs][1], it combines `seed` with the hash of `v` by

&lt;!-- language: cpp --&gt;
    seed ^= hash_value(v) + 0x9e3779b9 + (seed &lt;&lt; 6) + (seed &gt;&gt; 2);

I can see that this is deterministic. I see why a XOR is used.

I bet the addition helps in mapping similar values widely apart so probing hash tables won&#39;t break down, but can someone explain what the magic constant is?


  [1]: http://www.boost.org/doc/libs/release/doc/html/hash/reference.html#boost.hash_combine

Magic number in boost::hash_combine

The <code>boost::hash_combine</code> template function takes a reference to a hash (called <code>seed</code>) and an object <code>v</code>. According to the <a href="http://www.boost.org/doc/libs/release/doc/html/hash/reference.html#boost.hash_combine" target="_blank" rel="noopener noreferrer">docs</a>, it combines <code>seed</code> with the hash of <code>v</code> by

seed ^= hash_value(v) + 0x9e3779b9 + (seed &#x3C;&#x3C; 6) + (seed >> 2);
I can see that this is deterministic. I see why a XOR is used.
I bet the addition helps in mapping similar values widely apart so probing hash tables won't break down, but can someone explain what the magic constant is?

I&#39;m running through some example programs to refamiliarize myself with C++ and I have run into the following question.  First, here is the example code:

    void print_string(const char * the_string)
    {
    	cout &lt;&lt; the_string &lt;&lt; endl;
    }
    
    int main () {
    	print_string(&quot;What&#39;s up?&quot;);
    }

In the above code, the parameter to `print_string` could have instead been `const char * const the_string`.  Which would be more correct for this?  

I understand that the difference is that one is a `pointer to a constant character`, while the other one is a `constant pointer to a constant character`.  But why do both of these work?  When would it be relevant?

`const char * const` versus `const char *`?

Im trying to figure out how to reverse the string `temp` when I have the string read in binary numbers 

    istream&amp; operator &gt;&gt;(istream&amp; dat1d, binary&amp; b1)    
    {              
        string temp; 
        
        dat1d &gt;&gt; temp;    
    }

How to reverse an std::string?

In Visual Studio 2010, under `VC++ Directories &gt; Executable Directories`, I have specified the path to `glew32d.dll`. However, when I run the executable, it still complains.

On the other hand, if I copy the DLL into the local folder and run the executable then, it doesn&#39;t complain.

Can someone please tell me how to fix this? Also, why is Visual Studio not recognizing that path?

**Update**
Scenario: I currently use a template project which I use as a starter code for a lot of my projects. This template depends on glew32d.dll. I usually store all dependent dlls in a common bin folder. I was hoping to reference this folder and Visual studio could read the dlls from there, instead of me having to copy the dlls everytime. What would be a good way to handle this?

Why can&#39;t Visual Studio find my DLL?

I&#39;m using a lot of `qDebug() &lt;&lt;` statements for debug output. Is there any cross-platform way I can redirect that debug output to a file, without resorting to shell scripts? I&#39;m guessing that [open()][1] and [dup2()][2] will do the job in Linux, but will it work compiled with MinGW in Windows?

And maybe there is a Qt way to do it?


  [1]: http://opennet.ru/man.shtml?topic=open&amp;category=2&amp;russian=0
  [2]: http://opennet.ru/man.shtml?topic=dup2&amp;category=2&amp;russian=0

How to redirect qDebug, qWarning, qCritical etc output?

Please include an example with the explanation.

What does &quot;dereferencing&quot; a pointer mean?

Does the opposite of Kruskal&#39;s algorithm for minimum spanning tree work for it? I mean, choosing the max weight (edge) every step?

Any other idea to find maximum spanning tree?

How to find maximum spanning tree?

Suppose that I have an *n*-sided loaded die, where each side&amp;nbsp;*k* has some probability&amp;nbsp;*p*&lt;sub&gt;*k*&lt;/sub&gt; of coming up when I roll it. I’m curious if there is a good data structure for storing this information statically (i.e., for a fixed set of probabilities), so that I can efficiently simulate a random roll of the die.

Currently, I have an O(lg&amp;nbsp;*n*) solution for this problem. The idea is to store a table of the cumulative probability of the first *k*&amp;nbsp;sides for all&amp;nbsp;*k*, then generate a random real number in the range&amp;nbsp;[0,&amp;nbsp;1) and perform a binary search over the table to get the largest index whose cumulative value is no greater than the chosen value.

I rather like this solution, but it seems odd that the runtime doesn’t take the probabilities into account. In particular, in the extreme cases of one side always coming up or the values being uniformly distributed, it’s possible to generate the result of the roll in&amp;nbsp;O(1) using a naive approach, while my solution will still take logarithmically many steps.

Does anyone have any suggestions for how to solve this problem in a way that is somehow “adaptive” in it’s runtime?

**Update:** Based on the answers to this question, I have written up **[an article describing many approaches to this problem][1]**, along with their analyses. It looks like Vose’s implementation of the alias method gives &amp;Theta;(*n*)&amp;nbsp;preprocessing time and O(1)&amp;nbsp;time per die roll, which is truly impressive.  Hopefully this is a useful addition to the information contained in the answers!


  [1]: http://www.keithschwarz.com/darts-dice-coins/

Data structures for loaded dice?

To simplify the problem, I have a graph that contains nodes and edges which are on a 2D plane.

What I want to be able to do is click a button and it make the automatically layout the graph to look clean. By that I mean minimal crossing of edges, nice space between nodes, maybe even represent the graph scale (weighted edges).

I know this is completely subjective of what is a clean looking graph, but does anyone know of an algorithm to start with, rather than reinventing the wheel?

Thanks.

Graph auto-layout algorithm

Given a database of places with Latitude + Longitude locations, such as 40.8120390, -73.4889650, how would I find all locations within a given distance of a specific location?

It doesn&#39;t seem very efficient to select all locations from the DB and then go through them one by one, getting the distance from the starting location to see if they are within the specified distance. Is there a good way to narrow down the initially selected locations from the DB? Once I have (or don&#39;t?) a narrowed down set of locations, do I still go through them one by one to check the distance, or is there a better way?

The language I do this in doesn&#39;t really matter. Thanks!

Algorithm to find all Latitude Longitude locations within a certain distance from a given Lat Lng location

A 2-way merge is widely studied as a part of Mergesort algorithm.
But I am interested to find out the best way one can perform an N-way merge?

Lets say, I have `N` files which have sorted 1 million integers each.
I have to merge them into 1 single file which will have those 100 million sorted integers.

Please keep in mind that use case for this problem is actually external sorting which is disk based. Therefore, in real scenarios there would be memory limitation as well. So a naive approach of merging 2 files at a time (99 times) won&#39;t work. Lets say we have only a small sliding window of memory available for each array.

I am not sure if there is already a standardized solution to this N-way merge. *(Googling didn&#39;t tell me much)*.

But if you know if a good n-way merge algorithm, please post algo/link.

**Time complexity:** If we greatly increase the number of files (`N`) to be merged, how would that affect the time complexity of your algorithm?

Thanks for your answers.

*I haven&#39;t been asked this anywhere, but I felt this could be an interesting interview question. Therefore tagged.*

Algorithm for N-way merge

I heard on a forum using `std::function&lt;&gt;` causes performance drop. Is it true? If true, is it a big performance drop?

What is the performance overhead of std::function?

I&#39;m using Boost Program Options Library to parse the command line arguments.

I have the following requirements:

 1. Once &quot;help&quot; is provided, all the other options are optional;
 2. Once &quot;help&quot; is not provided, all the other options are required.

How I can deal with this?  Here is the my code handling this, and I found it&#39;s very redundant, and I think there must be an easy to do, right?

    #include &lt;boost/program_options.hpp&gt;
    #include &lt;iostream&gt;
    #include &lt;sstream&gt;
    namespace po = boost::program_options;
    
    bool process_command_line(int argc, char** argv,
                              std::string&amp; host,
                              std::string&amp; port,
                              std::string&amp; configDir)
    {
        int iport;
    
        try
        {
            po::options_description desc(&quot;Program Usage&quot;, 1024, 512);
            desc.add_options()
              (&quot;help&quot;,     &quot;produce help message&quot;)
              (&quot;host,h&quot;,   po::value&lt;std::string&gt;(&amp;host),      &quot;set the host server&quot;)
              (&quot;port,p&quot;,   po::value&lt;int&gt;(&amp;iport),             &quot;set the server port&quot;)
              (&quot;config,c&quot;, po::value&lt;std::string&gt;(&amp;configDir), &quot;set the config path&quot;)
            ;
    
            po::variables_map vm;
            po::store(po::parse_command_line(argc, argv, desc), vm);
            po::notify(vm);
    
            if (vm.count(&quot;help&quot;))
            {
                std::cout &lt;&lt; desc &lt;&lt; &quot;\n&quot;;
                return false;
            }
    
            // There must be an easy way to handle the relationship between the
            // option &quot;help&quot; and &quot;host&quot;-&quot;port&quot;-&quot;config&quot;
            if (vm.count(&quot;host&quot;))
            {
                std::cout &lt;&lt; &quot;host:   &quot; &lt;&lt; vm[&quot;host&quot;].as&lt;std::string&gt;() &lt;&lt; &quot;\n&quot;;
            }
            else
            {
                std::cout &lt;&lt; &quot;\&quot;host\&quot; is required!&quot; &lt;&lt; &quot;\n&quot;;
                return false;
            }
    
            if (vm.count(&quot;port&quot;))
            {
                std::cout &lt;&lt; &quot;port:   &quot; &lt;&lt; vm[&quot;port&quot;].as&lt;int&gt;() &lt;&lt; &quot;\n&quot;;
            }
            else
            {
                std::cout &lt;&lt; &quot;\&quot;port\&quot; is required!&quot; &lt;&lt; &quot;\n&quot;;
                return false;
            }
    
            if (vm.count(&quot;config&quot;))
            {
                std::cout &lt;&lt; &quot;config: &quot; &lt;&lt; vm[&quot;config&quot;].as&lt;std::string&gt;() &lt;&lt; &quot;\n&quot;;
            }
            else
            {
                std::cout &lt;&lt; &quot;\&quot;config\&quot; is required!&quot; &lt;&lt; &quot;\n&quot;;
                return false;
            }
        }
        catch(std::exception&amp; e)
        {
            std::cerr &lt;&lt; &quot;Error: &quot; &lt;&lt; e.what() &lt;&lt; &quot;\n&quot;;
            return false;
        }
        catch(...)
        {
            std::cerr &lt;&lt; &quot;Unknown error!&quot; &lt;&lt; &quot;\n&quot;;
            return false;
        }
    
        std::stringstream ss;
        ss &lt;&lt; iport;
        port = ss.str();
    
        return true;
    }
    
    int main(int argc, char** argv)
    {
      std::string host;
      std::string port;
      std::string configDir;
    
      bool result = process_command_line(argc, argv, host, port, configDir);
      if (!result)
          return 1;
    
      // Do the main routine here
    }


Required and Optional Arguments Using Boost Library Program Options

I understand how to use `weak_ptr` and `shared_ptr`. I understand how `shared_ptr` works, by counting the number of references in its object. How does `weak_ptr` work? I tried reading through the boost source code, and I&#39;m not familiar enough with boost to understand all the things it uses.

Thanks.

How does weak_ptr work?

I&#39;m using the `boost::split` method to split a string as this:

I first make sure to include the correct header to have access to `boost::split`:

    #include &lt;boost/algorithm/string.hpp&gt;

then:

	vector&lt;string&gt; strs;
	boost::split(strs,line,boost::is_any_of(&quot;\t&quot;));

and the line is like

    &quot;test	test2	test3&quot;

This is how I consume the result string vector:

    void printstrs(vector&lt;string&gt; strs)
	{
    	for(vector&lt;string&gt;::iterator it = strs.begin();it!=strs.end();++it)
		{
    		cout &lt;&lt; *it &lt;&lt; &quot;-------&quot;;
    	}
		
    	cout &lt;&lt; endl;
    }

But why in the result `strs` I only get `&quot;test2&quot;` and `&quot;test3&quot;`, shouldn&#39;t be `&quot;test&quot;`, `&quot;test2&quot;` and `&quot;test3&quot;`, there are `\t` (tab) in the string.

**Updated Apr 24th, 2011:** It seemed after I changed one line of code at `printstrs` I can see the first string. I changed 

    cout &lt;&lt; *it &lt;&lt; &quot;-------&quot;;

to 

    cout &lt;&lt; *it &lt;&lt; endl;

And it seemed `&quot;-------&quot;` covered the first string somehow.

c++ boost split string

The question is in bold at the bottom, the problem is also summarized by the distillation code fragment towards the end.

I am trying to unify my type system (the type system does to and from from type to string) into a single component(as defined by Lakos). I am using `boost::array`, `boost::variant`, and `boost::mpl`, in order to achieve this. I want to have the parser and generator rules for my types unified in a variant. there is a undefined type, a int4(see below) type and a int8 type. The variant reads as `variant&lt;undefined, int4,int8&gt;`.

int4 traits: 
```cpp
    struct rbl_int4_parser_rule_definition
    {
      typedef boost::spirit::qi::rule&lt;std::string::iterator, rbl_int4()&gt; rule_type;
      
      boost::spirit::qi::int_parser&lt;rbl_int4&gt; parser_int32_t;
      
      rule_type rule;
      
      rbl_int4_parser_rule_definition()
      {
        rule.name(&quot;rbl int4 rule&quot;);
        rule = parser_int32_t;  
      }
    };
    
    template&lt;&gt;
    struct rbl_type_parser_rule&lt;rbl_int4&gt;
    {
      typedef rbl_int4_parser_rule_definition string_parser;
    };
```
the variant above starts out as undefined, and then I initialize the rules. I had a problem, which caused 50 pages of errors, and I have finally managed to track it down, Variant uses `operator=` during assignment and a `boost::spirit::qi::int_parser&lt;&gt;` cannot be assigned to another (operator=).

To contrast, I don&#39;t have a problem with my undefined type:
```cpp
    struct rbl_undefined_parser_rule_definition
    {
      typedef boost::spirit::qi::rule&lt;std::string::iterator, void()&gt; rule_type;
      rule_type rule;
      
      rbl_undefined_parser_rule_definition()
      {
        rule.name(&quot;undefined parse rule&quot;);
        rule = boost::spirit::qi::eps;
      }
    };
    
    template&lt;&gt;
    struct rbl_type_parser_rule&lt;rbl_undefined&gt;
    {
      typedef rbl_undefined_parser_rule_definition string_parser;
    };
```
Distillation of the problem:
```cpp
    #include &lt;string&gt;
    #include &lt;boost/spirit/include/qi.hpp&gt;
    #include &lt;boost/variant.hpp&gt;
    #include &lt;boost/cstdint.hpp&gt;
    
    typedef boost::spirit::qi::rule&lt;std::string::iterator,void()&gt; r1;
    typedef boost::spirit::qi::rule&lt;std::string::iterator,int()&gt; r2;
    
    typedef boost::variant&lt;r1,r2&gt; v;
    
    int main()
    {
      /*
      problematic
      boost::spirit::qi::int_parser&lt;int32_t&gt; t2;
      boost::spirit::qi::int_parser&lt;int32_t&gt; t1;
      
      
      t1 = t2;
      */
    
      //unproblematic
      r1 r1_;
      r2 r2_;
      r1_ = r2_;
    
      v v_;
      // THIS is what I need to do.
      v_ = r2();
    }
```
There is a semantic gap between concrete parsers and rules. My brain is smoking at the moment so I am not going to think about pramatism, **My question is, how do I solve this problem ?**  I can think of three approaches to solve the problem.

**one:** Static function members:
```cpp
    struct rbl_int4_parser_rule_definition
    {
      typedef boost::spirit::qi::rule&lt;std::string::iterator, rbl_int4()&gt; rule_type;
      
      //boost::spirit::qi::int_parser&lt;rbl_int4&gt; parser_int32_t;
      
      rule_type rule;
      
      rbl_int4_parser_rule_definition()
      {
        static boost::spirit::qi::int_parser&lt;rbl_int4&gt; parser_int32_t;
    
        rule.name(&quot;rbl int4 rule&quot;);
        rule = parser_int32_t;  
      }
    };
```
I guess approach one prevents thread safe code  ? ? 

**two:** The integral parser is wrapped in a shared_ptr. There are two reasons I&#39;m bothering with TMP for the typing system: 1 efficiency, 2 centralizing concerns into components. using pointers defeats the first reason.

**three:** operator= is defined as a no-op. variant guarantees that the `lhs` is default constructed before assignment.

**Edit:**
I am thinking option 3 makes the most sense (operator= is a no-op). Once the rule container is created it will not change, and I am only assigning to force a type&#39;s rule trait into its offset.

more spirit madness - parser-types (rules vs int_parser&lt;&gt;) and meta-programming techniques

I&#39;m looking at some code that I have not written myself. The code tries to hash a password with SHA512 and uses just `time()` as the salt. Is `time()` too simple a salt for this or is this code safe?

Thanks for the answers and comments. I will sum it up here for the new readers:

- salt should be different for each user, so if 2 users register at the same time, their salts won&#39;t be unique. This is a problem, but not a big one. 
- but salt shouldn&#39;t be in any way related to the user, so time() is not a good salt. 
- &quot;*Use a random, evenly distributed, high entropy salt.*&quot; -- That&#39;s a mouthful, so what code could possibly generate a `random, evenly distributed, high entropy` salt?

Ok, so how about I replace time() with a random string 32 char long. The random string could be generated from looping 32 times over a set of alphabet chars. Does that sound good?

Is time() a good salt?

Looking for a way to produce a filename-safe hash of a given PHP array.  I&#39;m currently doing:

    $filename = md5(print_r($someArray, true));

... but it feels &quot;hacky&quot; using print_r() to generate a string unique to each array.

Any bright ideas for a cleaner way to do this?


**EDIT**
Well, seems everyone thinks serialize is better suited to the task.  Any reason why?  I&#39;m not worried about ever retrieving information about the variable after it&#39;s hashed (which is good, since it&#39;s a one-way hash!). Thanks for the replies!


Hashing an entire PHP array into a unique value

I want to change every value in a hash so as to add &#39;%&#39; before and after the value so


    { :a=&gt;&#39;a&#39; , :b=&gt;&#39;b&#39; }

must be changed to

    { :a=&gt;&#39;%a%&#39; , :b=&gt;&#39;%b%&#39; }

What&#39;s the best way to do this?

Changing every value in a hash in Ruby

Say:

    h = { 1 =&gt; 10, 2 =&gt; 20, 5 =&gt; 70, 8 =&gt; 90, 4 =&gt; 34 }

I would like to change each value `v` to `foo(v`), such that `h` will be:

    h = { 1 =&gt; foo(10), 2 =&gt; foo(20), 5 =&gt; foo(70), 8 =&gt; foo(90), 4 =&gt; foo(34) }

What is the most elegant way to achieve this ?



Ruby: What is the easiest method to update Hash values?

To check what `@some_var` is, I am doing a

    if @some_var.class.to_s == &#39;Hash&#39; 

I am sure there is a more elegant way to check if `@some_var` is a `Hash` or an `Array`.

What is a elegant way in Ruby to tell if a variable is a Hash or an Array?

I tried to load my R workspace and received this error:

    Error: bad restore file magic number (file may be corrupted) -- no data loaded
    In addition: Warning message:
    file ‘WORKSPACE_Wedding_Weekend_September’ has magic number &#39;#gets&#39;
       Use of save versions prior to 2 is deprecated 


I&#39;m not particularly interested in the technical details, but mostly in how I caused it and how I can prevent it in the future.  Here&#39;s some notes on the situation:

 1. I&#39;m running R 2.15.1 on a MacBook Pro running Windows XP on a bootcamp partition.
 2. There is something obviously wrong this workspace file, since it weighs in at only ~80kb while all my others are usually &gt;10,000
 3. Over the weekend I was running an external modeling program in R and storing its output to different objects.  I ran several iterations of the model over the course of several days, eg output_Saturday &lt;- call_model()
 4. There is nothing special to the model output, its just a list with slots for betas, VC-matrices, model specification, etc.



The cause of &quot;bad magic number&quot; error when loading a workspace and how to avoid it?

I keep seeing this constant pop up in various graphics header files

    0.0039215689

It seems to have something to do with color maybe?

Here is the first [hit on Google](http://ozmav.googlecode.com/svn-history/r178/trunk/badrdp/rdp.c):

    void RDP_G_SETFOGCOLOR(void)
    {
    	Gfx.FogColor.R = _SHIFTR(w1, 24, 8) * 0.0039215689f;
    	Gfx.FogColor.G = _SHIFTR(w1, 16, 8) * 0.0039215689f;
    	Gfx.FogColor.B = _SHIFTR(w1, 8, 8) * 0.0039215689f;
    	Gfx.FogColor.A = _SHIFTR(w1, 0, 8) * 0.0039215689f;
    }
    
    void RDP_G_SETBLENDCOLOR(void)
    {
    	Gfx.BlendColor.R = _SHIFTR(w1, 24, 8) * 0.0039215689f;
    	Gfx.BlendColor.G = _SHIFTR(w1, 16, 8) * 0.0039215689f;
    	Gfx.BlendColor.B = _SHIFTR(w1, 8, 8) * 0.0039215689f;
    	Gfx.BlendColor.A = _SHIFTR(w1, 0, 8) * 0.0039215689f;
    
    	if(OpenGL.Ext_FragmentProgram &amp;&amp; (System.Options &amp; BRDP_COMBINER)) {
    		glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 2, Gfx.BlendColor.R, Gfx.BlendColor.G, Gfx.BlendColor.B, Gfx.BlendColor.A);
    	}
    }

    //...more like this

What does this number represent? Why does no one seem to declare it as a const?

I couldn&#39;t find anything on Google that explained it.

Content Type	Original Author	Original Content on Stackoverflow
Question	Fred Foo	View Question on Stackoverflow
Solution 1 - C++	Mike Seymour	View Answer on Stackoverflow
Solution 2 - C++	NPE	View Answer on Stackoverflow

Magic number in boost::hash_combine

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Javascript Math Object Methods - negatives to zero

Jackson + Builder Pattern?

Attributions