Am 21.01.2016 um 16:10 schrieb Allin Cottrell:
> Your example shows that recursion is a _lot_ faster in julia; so now we
> want a case where recursion is actually needed.
>
One more thought on this: What about the "omit --auto" command? I guess
this could be viewed as something that is done recursively, like this in
pseudo code:
function <reduced-equation> omit_one_by_one(<estimated-equation>)
if min(<signif>) < threshold
eliminate(coeff_where_min(<signif>))
omit_one_by_one(<equ_reduced_by_one>)
else
return <estimated-equation>
endif
end function
If somebody is already proficient enough in Julia (or some other
JIT-compiled language), I think it would be interesting to compare the
speed to gretl's performance there.

Many things are such that they _can_ be done by recursion (in the
sense of a function calling itself), or they can be done by a
non-recursive iteration (as in gretl's "omit --auto"), or possibly
by a simple closed-form calculation (Fibonacci numbers).
I was suggesting that we might try to think of calculations relevant
to econometrics that are _best_ solved via recursion, given julia's
huge advantage in that area; I kinda doubt whether auto-omission
falls in that category, though if anyone cares to try that would be
nice.
Another thing to consider: julia is amazingly fast at "general
computation" (almost as fast as C) but once you start using packages
-- such as GLM for regression -- you pay a big cost in set-up time,
and the package code may not be anything like as efficient as the
built-in functions. Here's a trivial example, compounded of examples
from the julia GLM documentation:
<julia>
using GLM, RDatasets
form = dataset("datasets","Formaldehyde")
lm1 = fit(LinearModel, OptDen ~ Carb, form)
cycle = dataset("datasets", "LifeCycleSavings")
fm2 = fit(LinearModel, SR ~ Pop15 + Pop75 + DPI + DDPI, cycle)
</julia>
Running this on my i7 machine takes around 5.8 seconds (the "real"
value from the unix "time" program). Then here's the gretl
equivalent (after having used R to write out the two datasets as
.dta files):
<hansl>
open formaldehyde.dta -q
ols optden 0 carb
open lifecycle.dta -q
ols sr 0 pop15 pop75 dpi ddpi
</hansl>
Running time: 0.017 seconds, or 340 times faster.
We may suppose that there's a big fixed cost in the julia case, so
my next step was to wrap each estimation function/command in a
loop of 100000 replications (and eliminate the printing). That gave:
julia: 30.928s
gretl: 0.747s
OK, so now gretl is only 40 times as fast. What about a million
replications?
julia: 4m21.023s
gretl: 0m6.138s
Still 40 x faster, so it's by no means all to do with a fixed set-up
cost.
Once again, I don't doubt there _are_ computations we could
outsource to julia with advantage, but it seems clear that running
regressions via GLM is not one of them.
Allin