Most Euler numeric integration methods suffer from cumulative round-off error that will eventually cause the simulation to &quot;blow up&quot;.  You may want to investigate advanced numerical integration methods, such as 4th-order Runge-Kutta or predictor-corrector.

Another place where n-body problem simulations become sticky is when two bodies get very close, such as a moon with a very eccentric orbit about its planet.  If one uses fixed time increments for the simulation, the error during large changes of angular velocity can lead to division-by-zero errors or division by very small values that result in the simulation blowing up.  Use of a variable delta-t that depends on the angular velocity can be beneficial.

These suggestions are based on running many such simulations as a project for an undergraduate physics course I took in 1973, while testing various numerical integration methods.  Runge-Kutta and predictor corrector methods have been around since the dawn of digital computing and a number of books are available.  See, *e.g.*, ***Numerical Recipes: The Art of Scientific Computing*** by William H. Press, Brian P. Flannery, Saul A. Teukolsky and William T. Vetterling. (Cambridge University Press, 1989)

I am using syntastic in my c++11 project. When I am editing in vim, and save (:w) the syntastic plugin gives me errors on every initializer list {} and for each loops which are clearly c++11 features that it&#39;s missing. 

I installed syntastic using pathogen.

Here are two examples of the error I am getting on initializer lists and for each loops (both c++11 that compile fine): 

![error on initializer lists][1] 
![error on for each loop][2]


  [1]: http://i.stack.imgur.com/B6aDb.jpg
  [2]: http://i.stack.imgur.com/xjXix.jpg

how to add c++11 support to syntastic vim plugin?

I have an HTML 5 video in a div. I then have a custom play button - that works fine.  
And I have the video&#39;s visibility set to hidden on load and visible when the play button is clicked, how do I return it to hidden when the play button is clicked again?

     

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    function showVid() {
      document.getElementById(&#39;video-over&#39;).style.visibility = &#39;visible&#39;;
    }

&lt;!-- language: lang-css --&gt;

    #video-over {
      visibility: hidden;
      background-color: rgba(0, 0, 0, .7)
    }

&lt;!-- language: lang-html --&gt;

    &lt;div id=&quot;video-over&quot;&gt;
      &lt;video class=&quot;home-banner&quot; id=&quot;video&quot; controls=&quot;&quot;&gt;
        &lt;source src=&quot;http://video-js.zencoder.com/oceans-clip.mp4&quot; type=&#39;video/mp4&#39; /&gt;
        &lt;source src=&quot;http://video-js.zencoder.com/oceans-clip.webm&quot; type=&#39;video/webm&#39; /&gt;
        &lt;source src=&quot;http://video-js.zencoder.com/oceans-clip.ogv&quot; type=&#39;video/ogg&#39; /&gt;
        &lt;/video&gt;
    &lt;/div&gt;

    &lt;button type=&quot;button&quot; id=&quot;play-pause&quot; onclick=&quot;showVid();&quot;&gt;
          &lt;img class=&quot;img-home-apply&quot; src=&quot;/wp-content/images/apply-pic.png&quot; alt=&quot;Apply Now&quot;&gt;
          &lt;/button&gt;

&lt;!-- end snippet --&gt;

I&#39;m basically just trying to toggle it between the two states of visible and hidden except I can&#39;t use toggle because that show&#39;s and hides the div. I need it there, just hidden, so it maintains the correct height.    

Toggle visibility property of div

I have written a simulation of the outer planets of the solar system using the [Euler symplectic method][1] and implemented this a) using `repa` and b) using `yarr`.

[`yarr` seems to perform about x30 quicker than `repa`][2].

Given this, I didn&#39;t even try to use parallelism. Is there any obvious performance problems in my `repa` code? The repository is at [github][3]. I can produce a cut-down `repa`-only version if this is helpful, but then you won&#39;t get the performance comparison against `yarr`.

Alternatively, how do I debug performance issues in `repa`?


  [1]: https://en.wikipedia.org/wiki/Semi-implicit_Euler_method
  [2]: http://idontgetoutmuch.wordpress.com/2013/08/06/planetary-simulation-with-excursions-in-symplectic-manifolds-6/
  [3]: https://github.com/idontgetoutmuch/Leapfrog

&#39;Repa&#39; performance for planetary simulation

I have written a simulation of the outer planets of the solar system using the <a href="https://en.wikipedia.org/wiki/Semi-implicit_Euler_method" target="_blank" rel="noopener noreferrer">Euler symplectic method</a> and implemented this a) using <code>repa</code> and b) using <code>yarr</code>.
<a href="http://idontgetoutmuch.wordpress.com/2013/08/06/planetary-simulation-with-excursions-in-symplectic-manifolds-6/" target="_blank" rel="noopener noreferrer"><code>yarr</code> seems to perform about x30 quicker than <code>repa</code></a>.
Given this, I didn't even try to use parallelism. Is there any obvious performance problems in my <code>repa</code> code? The repository is at <a href="https://github.com/idontgetoutmuch/Leapfrog" target="_blank" rel="noopener noreferrer">github</a>. I can produce a cut-down <code>repa</code>-only version if this is helpful, but then you won't get the performance comparison against <code>yarr</code>.
Alternatively, how do I debug performance issues in <code>repa</code>?

I want to create a two dimensional array in Javascript where I&#39;m going to store coordinates (x,y). I don&#39;t know yet how many pairs of coordinates I will have because they will be dynamically generated by user input.

Example of pre-defined 2d array:

    var Arr=[[1,2],[3,4],[5,6]];

I guess I can use the PUSH method to add a new record at the end of the array. 

How do I declare an empty two dimensional array so that when I use my first Arr.push() it will be added to the index 0, and every next record written by push will take the next index?

This is probably very easy to do, I&#39;m just a newbie with JS, and I would appreciate if someone could write a short working code snippet that I could examine. Thanks

Declare an empty two-dimensional array in Javascript?

PHP trivia here.

If we declare an array like this:

    &lt;?php $arr = [ &#39;foo&#39; =&gt; &#39;bar&#39;, NULL =&gt; &#39;hello&#39; ]; ?&gt;

We can access it like this

    print $arr[NULL];

This will print `hello`. Why is this useful, relevant or necessary? Is it a PHP bug or a feature?

My only idea was that you could declare array with the NULL key being equal to an error message to explain to anyone who uses a NULL key that their key is null:

    $arr[NULL] = &#39;Warning you have used a null key, did you mean to?&#39;;

Has anyone found this useful? Seems to be something to cause more harm than good.

Arrays with NULL keys

Given an array, a single element, or nil, obtain an array - the latter two being a single element array and an empty array respectively.

I mistakenly figured Ruby would work this way:

    [1,2,3].to_a  #= [1,2,3]     # Already an array, so no change
    1.to_a        #= [1]         # Creates an array and adds element
    nil.to_a      #= []          # Creates empty array

But what you really get is:

    [1,2,3].to_a  #= [1,2,3]         # Hooray
    1.to_a        #= NoMethodError   # Do not want
    nil.to_a      #= []              # Hooray

So to solve this, I either need to use another method, or I could meta program by modifying the to_a method of all classes I intend to use - which is not an option for me.

So a Method it is:
     
    result = nums.class == &quot;Array&quot;.constantize ? nums : (nums.class == &quot;NilClass&quot;.constantize ? [] : ([]&lt;&lt;nums))

The problem is that it is a bit of a mess. Is there an elegant way of doing this? (I would be amazed if this is the Ruby-ish way to solve this problem)

----
What applications does this have? Why even convert to an array?
--
In Rails&#39; ActiveRecord, calling say, `user.posts` will either return an array of posts, a single post, or nil. When writing methods which work on the results of this, it is easiest to assume that the method will take an array, which may have zero, one, or many elements. Example method:

    current_user.posts.inject(true) {|result, element| result and (element.some_boolean_condition)}

Ruby - elegantly convert variable to an array if not an array already

Lets start with three arrays of `dtype=np.double`. Timings are performed on a intel CPU using numpy 1.7.1 compiled with `icc` and linked to intel&#39;s `mkl`. A AMD cpu with numpy 1.6.1 compiled with `gcc` without `mkl` was also used to verify the timings. Please note the timings scale nearly linearly with system size and are not due to the small overhead incurred in the numpy functions `if` statements these difference will show up in microseconds not milliseconds:

    arr_1D=np.arange(500,dtype=np.double)
    large_arr_1D=np.arange(100000,dtype=np.double)
    arr_2D=np.arange(500**2,dtype=np.double).reshape(500,500)
    arr_3D=np.arange(500**3,dtype=np.double).reshape(500,500,500)

First lets look at the `np.sum` function:

    np.all(np.sum(arr_3D)==np.einsum(&#39;ijk-&gt;&#39;,arr_3D))
    True
    
    %timeit np.sum(arr_3D)
    10 loops, best of 3: 142 ms per loop

    %timeit np.einsum(&#39;ijk-&gt;&#39;, arr_3D)
    10 loops, best of 3: 70.2 ms per loop

Powers:

    np.allclose(arr_3D*arr_3D*arr_3D,np.einsum(&#39;ijk,ijk,ijk-&gt;ijk&#39;,arr_3D,arr_3D,arr_3D))
    True

    %timeit arr_3D*arr_3D*arr_3D
    1 loops, best of 3: 1.32 s per loop
    
    %timeit np.einsum(&#39;ijk,ijk,ijk-&gt;ijk&#39;, arr_3D, arr_3D, arr_3D)
    1 loops, best of 3: 694 ms per loop

Outer product:

    np.all(np.outer(arr_1D,arr_1D)==np.einsum(&#39;i,k-&gt;ik&#39;,arr_1D,arr_1D))
    True
    
    %timeit np.outer(arr_1D, arr_1D)
    1000 loops, best of 3: 411 us per loop
    
    %timeit np.einsum(&#39;i,k-&gt;ik&#39;, arr_1D, arr_1D)
    1000 loops, best of 3: 245 us per loop


All of the above are twice as fast with `np.einsum`. These should be apples to apples comparisons as everything is specifically of `dtype=np.double`. I would expect the speed up in an operation like this:

    np.allclose(np.sum(arr_2D*arr_3D),np.einsum(&#39;ij,oij-&gt;&#39;,arr_2D,arr_3D))
    True

    %timeit np.sum(arr_2D*arr_3D)
    1 loops, best of 3: 813 ms per loop
    
    %timeit np.einsum(&#39;ij,oij-&gt;&#39;, arr_2D, arr_3D)
    10 loops, best of 3: 85.1 ms per loop
    

Einsum seems to be at least twice as fast for `np.inner`, `np.outer`, `np.kron`, and `np.sum` regardless of `axes` selection. The primary exception being `np.dot`  as it calls DGEMM from a BLAS library. So why is `np.einsum` faster that other numpy functions that are equivalent?

The DGEMM case for completeness:

    np.allclose(np.dot(arr_2D,arr_2D),np.einsum(&#39;ij,jk&#39;,arr_2D,arr_2D))
    True
    
    %timeit np.einsum(&#39;ij,jk&#39;,arr_2D,arr_2D)
    10 loops, best of 3: 56.1 ms per loop
    
    %timeit np.dot(arr_2D,arr_2D)
    100 loops, best of 3: 5.17 ms per loop


----------

The leading theory is from @sebergs comment that `np.einsum` can make use of [SSE2][1], but numpy&#39;s ufuncs will not until numpy 1.8 (see the [change log][2]). I believe this is the correct answer, but have *not* been able to confirm it. Some limited proof can be found by changing the dtype of input array and observing speed difference and the fact that not everyone observes the same trends in timings.


  [1]: http://en.wikipedia.org/wiki/SSE2
  [2]: https://github.com/numpy/numpy/blob/master/doc/release/1.8.0-notes.rst

Why is numpy&#39;s einsum faster than numpy&#39;s built in functions?

I was hoping to find a way to create an array with the registered routes paths within Laravel 4.

Essentially, I am looking to get a list something like this returned:

    /
    /login
    /join
    /password

I did come across a method `Route::getRoutes()` which returns an object with the routes information as well as the resources but the path information is protected and I don&#39;t have direct access to the information. 

Is there any other way to achieve this? Perhaps a different method?

How to get a list of registered route paths in Laravel?

[`Alternative`](http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Applicative.html#t:Alternative), an extension of `Applicative`, declares `empty`, `&lt;|&gt;` and these two functions:

&gt; One or more:
&gt;
&gt;     some :: f a -&gt; f [a]
&gt;
&gt; Zero or more:
&gt;
&gt;     many :: f a -&gt; f [a]
&gt;
&gt; If defined, `some` and `many` should be the least solutions of the equations:
&gt;
&gt;     some v = (:) &lt;$&gt; v &lt;*&gt; many v
&gt;
&gt;     many v = some v &lt;|&gt; pure []

I couldn&#39;t find an instance for which `some` and `many` are defined. **What is their meaning and practical use?** Are they used at all? I&#39;ve been unable to grasp their purpose just from this definition.

**Update:** I&#39;m not asking what is `Alternative`, just what are `some` and `many`

What are Alternative&#39;s &quot;some&quot; and &quot;many&quot; useful for?

I am learning Haskell from [learnyouahaskell.com](http://learnyouahaskell.com). I am having trouble understanding type constructors and data constructors. For example, I don&#39;t really understand the difference between this:

    data Car = Car { company :: String  
                   , model :: String  
                   , year :: Int  
                   } deriving (Show) 
and this:

    data Car a b c = Car { company :: a  
                         , model :: b  
                         , year :: c   
                         } deriving (Show)  

I understand that the first is simply using one constructor (`Car`) to built data of type `Car`. I don&#39;t really understand the second one.

Also, how do data types defined like this:

    data Color = Blue | Green | Red

fit into all of this?

From what I understand, the third example (`Color`) is a type which can be in three states: `Blue`, `Green` or `Red`. But that conflicts with how I understand the first two examples: is it that the type `Car` can only be in one state, `Car`, which can take various parameters to build? If so, how does the second example fit in?

Essentially, I am looking for an explanation that unifies the above three code examples/constructs.


Haskell Type vs Data Constructor

While learning functional programming, I keep coming across the term &quot;reason about&quot; especially in the context of pure functions and/or referential transparency. Can somebody explain what exactly does this mean?

What does the term &quot;reason about&quot; mean in computer science?

I have scoured the internet for an actual explanation of what this keyword does. Every Haskell tutorial that I have looked at just starts using it randomly and never explains what it does (and I&#39;ve looked at many).

Here&#39;s a basic piece of code from *Real World Haskell* that uses `Just`. I understand what the code does, but I don&#39;t understand what the purpose or function of `Just` is. 

    lend amount balance = let reserve    = 100
                          newBalance = balance - amount
                      in if balance &lt; reserve
                         then Nothing
                         else Just newBalance


From what I have observed, it is related to `Maybe` typing, but that&#39;s pretty much all I have managed to learn.

A good explanation of what `Just` means would be very much appreciated.


What does the &quot;Just&quot; syntax mean in Haskell?

A discussion came up at work recently about Sets, which in Scala support the `zip` method and how this can lead to bugs, e.g.

    scala&gt; val words = Set(&quot;one&quot;, &quot;two&quot;, &quot;three&quot;)
    scala&gt; words zip (words map (_.length))
    res1: Set[(java.lang.String, Int)] = Set((one,3), (two,5))

I think it&#39;s pretty clear that `Set`s  shouldn&#39;t support a `zip` operation, since the elements are not ordered. However, it was suggested that the problem is that `Set` isn&#39;t really a functor, and shouldn&#39;t have a `map` method. Certainly, you can get yourself into trouble by mapping over a set. Switching to Haskell now,

    data AlwaysEqual a = Wrap { unWrap :: a }

    instance Eq (AlwaysEqual a) where
        _ == _ = True

    instance Ord (AlwaysEqual a) where
        compare _ _ = EQ

and now in ghci

    ghci&gt; import Data.Set as Set
    ghci&gt; let nums = Set.fromList [1, 2, 3]
    ghci&gt; Set.map unWrap $ Set.map Wrap $ nums
    fromList [3]
    ghci&gt; Set.map (unWrap . Wrap) nums
    fromList [1, 2, 3]

So `Set` fails to satisfy the functor law

        fmap f . fmap g = fmap (f . g)

It can be argued that this is not a failing of the `map` operation on `Set`s, but a failing of the `Eq` instance that we defined, because it doesn&#39;t respect the substitution law, namely that for two instances of `Eq` on A and B  and a mapping `f : A -&gt; B` then

        if x == y (on A) then f x == f y (on B)

which doesn&#39;t hold for `AlwaysEqual` (e.g. consider `f = unWrap`).

Is the substition law a sensible law for the `Eq` type that we should try to respect? Certainly, other equality laws are respected by our `AlwaysEqual` type (symmetry, transitivity and reflexivity are trivially satisfied) so substitution is the only place that we can get into trouble.

To me, substition seems like a very desirable property for the `Eq` class. On the other hand, some comments on a [recent Reddit discussion](http://www.reddit.com/r/haskell/comments/1njlqr/laws_for_the_eq_class/) include

&gt; &quot;Substitution seems stronger than necessary, and is basically quotienting the type, putting requirements on every function using the type.&quot;
&gt;
&gt; -- *godofpumpkins*


&gt; &quot;I also really don&#39;t want substitution/congruence since there are many legitimate uses for values which we want to equate but are somehow distinguishable.&quot;
&gt;
&gt; -- *sclv*


&gt; &quot;Substitution only holds for structural equality, but nothing insists `Eq` is structural.&quot;
&gt;
&gt; -- *edwardkmett*

These three are all pretty well known in the Haskell community, so I&#39;d be hesitant to go against them and insist on substitability for my `Eq` types!

Another argument against `Set` being a `Functor` - it is widely accepted that being a `Functor` allows you to transform the &quot;elements&quot; of a &quot;collection&quot; while preserving the shape. For example, this quote on the Haskell wiki (note that `Traversable` is a generalization of `Functor`)

&gt; &quot;Where `Foldable` gives you the ability to go through the structure processing the elements but throwing away the shape, `Traversable` allows you to do that whilst preserving the shape and, e.g., putting new values in.&quot;
&gt;
&gt; &quot;`Traversable` is about preserving the structure exactly as-is.&quot;

and in Real World Haskell

&gt; &quot;...[A] functor must preserve shape. The structure of a collection should not be affected by a functor; only the values that it contains should change.&quot;

Clearly, any functor instance for `Set` has the possibility to change the shape, by reducing the number of elements in the set.

But it seems as though `Set`s really should be functors (ignoring the `Ord` requirement for the moment - I see that as an artificial restriction imposed by our desire to work efficiently with sets, not an absolute requirement for any set. For example, sets of functions are a perfectly sensible thing to consider. In any case, Oleg [has shown](http://okmij.org/ftp/Haskell/set-monad.html) how to write efficient Functor and Monad instances for `Set` that don&#39;t require an `Ord` constraint). There are just too many nice uses for them (the same is true for the non-existant `Monad` instance).

Can anyone clear up this mess? Should `Set` be a `Functor`? If so, what does one do about the potential for breaking the Functor laws? What should the laws for `Eq` be, and how do they interact with the laws for `Functor` and the `Set` instance in particular?

Content Type	Original Author	Original Content on Stackoverflow
Question	idontgetoutmuch	View Question on Stackoverflow
Solution 1 - Arrays	Andrew P.	View Answer on Stackoverflow

'Repa' performance for planetary simulation

Arrays Problem Overview

Arrays Solutions

Solution 1 - Arrays

Toggle visibility property of div

how to add c++11 support to syntastic vim plugin?

Attributions