functional programming - Does MATLAB perform tail call optimization? -

I have recently learned Haskell, and whenever I try to move my other code to a pure working style. An important aspect of it considers all the variables as unchanging, that is, to make the constants, many computations that will be implemented using the loops in a compulsory style, they use recursive, which generally call each function call due to the allocation Due to a new stack frame, memory penalties are imposed. In the special case of tail call (where the return valve of a called function is immediately returned to caller's caller), however, this penalty can be done by tail call optimization (in a method). Essentially replacing a call with a jmp correctly after installing the stack). Does MATLAB execute TCO by default, or is there a way to say it?

If I have a normal tail-recursive function:

  function tailtest ( N) if n == 0; Feature memstats; Return; & Telestast (N-1); End   
 and call it so that it can be thoroughly revised:  
  set (0, 'Recency Limit', 10000); Tailtest (1000);   
 So it does not appear that the stack frame is eating too much memory, though, if I read it very deeply:  
  set (0, Rakersion limit ', 10000); Tailtest (5000);   
 Then (on my machine, today) MATLAB bus crashes: the process dies in an arbitrary manner.  
 I do not think this is doing any TCO with MATLAB; In such a case where a function tails-call, there is no local variable except in one place, in one place, it is almost as easy as anyone can hope for someone. Such: No, it appears that MATLAB does not at least do the TCO by default I have not seen (yet) seen for options that can enable it I would be surprised If any  
 In cases where we do not blow up the stack, how often does the Rickshausen cost? See my comment on Bill Quethth's reply: It seems that the upper position of time is not insignificant but not crazy.  
 ... After leaving that comment, Bill Ktheths removed their reply. Fine. So, I took a simple iterative implementation of the Fibonacci function and a simple tail-recursive one, which was essentially the same calculation in both, and was done on both time at  fib (60) . It takes around 2.5 times longer to run the recurring execution from an iterative one. Of course, the relative overhead will become smaller for those functions which work more than an addition and a subtraction counter repetition.  
 (I also agree with Delan's spirit: Naturally in Haskell, this type of excessive recursive code is usually likely to be unidiomatic in MATLAB.)