Why is Octave's function call overhead so much larger than both Matlab's and Python's?
Question: I have two pieces of code in Python and Octave that are structurally
identical. However, the Python version, implemented with numpy and scipy, is
~5x faster. I did a profile of the code, and I found that the main culprit in
the Octave code is 6 functions repeatedly called thousands of times in a loop.
These functions only compute numerical expressions, e.g. cos, cosh, so I was
surprised by how much time they were consuming (For reference, the two codes
both run under 2 seconds.)

I researched this strange phenomenon online and read a
[paper](http://www.researchgate.net/publication/221663825_Function_call_overhead_benchmarks_with_MATLAB_Octave_Python_Cythonand_C)
that showed that the function overhead in Octave, i.e. the setup needed for
the function to start executing the actual function code in the function's
body and cleaning it up afterwards, is approximately 30 times larger than that
of Matlab and approximately 100 times larger than that of Python.

This occurrence greatly baffles me--**How is it possible that calling a
function from Octave can be _this_ much slower than calling a function in the
two other similar languages? Furthermore, is there any way to remedy this
reduction in speed besides copying and pasting the function itself into the
body of the loop?**

EDIT: I've posted the main for loop from my code. It's an iterative
implementation of newton's method for multiple equations, so I'm not sure how
it could be vectorized.

    
    
    for k = 1:10    
      for l = 1:50
        % matrix of derivatives of equations with respect to variables
        a = [dEq1_dq1(p1, p2, q1, q2, i, j), dEq1_dq2(p1, p2, q1, q2, i, j); dEq2_dq1(p1, p2, q1, q2, i, j), dEq2_dq2(p1, p2, q1, q2, i, j)];
    
        % vector of equations
        b = [Eq1(p1, p2, q1, q2, i, j); Eq2(p1, p2, q1, q2, i, j)];
    
        % solution to ax=b
        x = a \ b;
    
        % iteratively update q
        q1 -= beta*x(1);
        q2 -= beta*x(2);
      endfor
    
      for l = 1:50
        a = [dEp1_dp1(p1, p2, q1, q2, i, j), dEp1_dp2(p1, p2, q1, q2, i, j); dEp2_dp1(p1, p2, q1, q2, i, j), dEp2_dp2(p1, p2, q1, q2, i, j)];
        b = [Ep1(p1, p2, q1, q2, i, j); Ep2(p1, p2, q1, q2, i, j)];
        x = a \ b;
    
        p1 -= beta*x(1);
        p2 -= beta*x(2);
      endfor
    endfor
    
    ...
    
    % derivatives of implicit equations with respect to variables
    function val = dEp1_dp1(p1, p2, q1, q2, i, j)
      % symmetric
      if mod(i, 2) == 1
        val = p1/(2*cos(p1/2)**2)+tan(p1/2);
      % anti-symmetric
      else
        val = tan(p1/2)/(p1**2)-1/(2*p1*cos(p1/2)**2);
      endif
    end
    
    ...
    
    function val = Ep1(p1, p2, q1, q2, i, j)    
      if mod(i, 2) == 1
        val = p2*tanh(p2/2)+p1*tan(p1/2);
      else
        val = (1/p2)*tanh(p2/2)-(1/p1)*tan(p1/2);
      endif
    end
    
    ...
    


Answer: Comparing performance between languages is tricky business. Octave will tell
you right away that you should vectorize your code. That's what the language
was designed for. Python compiles his code into byte-code and that will allow
for optimizations. Matlab has JIT which does the same. But not Octave. Octave
will do exactly what you wrote, and will read your program one line at a time.
This means that your performance will suffer if you don't write good code.

And while there might be a large overhead for making a function call (I didn't
check your numbers), that's not so important if you only make a few functions
calls. You will often be dealing with large arrays, so it's the actual
"sciency" computations that should be causing your performance issues (unless
of course, you don't write proper Octave programs and use unnecessary loops).

The functions you mentioned, `cos` and `cosh`, will accept a vector so there's
is no need to use a for loop for it.

