I gave Eureqa the following data: y=0 (x=-14..0), y=1 (x=1..18). I set the error metric to least absolute error, which eliminates many "ringing" and "horn" artifacts. When the functions allowed are only +,-,*,/, I get pretty decent rational function approximations, but because of Eureqa's "low complexity" bias, the numerator & denominator polynomials are _extremely sparse_. With / but not *, you can get continued fractions, but Eureqa doesn't like them. I changed the "complexity" of / to 1 from 2, but convergence to CF solutions is extremely slow. Eureqa seems highly biased towards "multiplying out" any polynomials. For example, I couldn't get Eureka to put out a "factored form" -- e.g., (1+x)*(2+x) -- at all. When the functions are expanded to include sines & cosines, you _don't_ get Fourier series, but weird sines composed with additional sines. When the functions include exp(x), we see functions like y = x/(x + exp(-9.45e9 * x)) With powers: y = 0^(0^x) y = x/(x + 0^x) With factorial: y = x/(x + factorial(-618*x)) With complementary error functions: y = erfc(53.8* erfc(4*x)) With error function: y = 0.5 + 0.5 * erf(21.2*x - 21.4) y = erf(x + x*erf(33*x)) With tanh function: y = tanh(x + x*tany(911*x)) y = 0.5 + 0.5 * tanh(9*x - 12.2) y = tanh(39 + 39*tanh(72.2*x - 22.4)) With Gaussian: y = gauss(5.21e22 * gauss(7+x)) With logistic function y = logistic(1.23e3 * x - 975) With floor function y = -floor(-0.0183*x) With ceiling function y = ceil(9.37e-5 * x) With abs function y = (x+|x|)/(1.03e-15 + x + |x|) -------------- Bottom line: I like the basic idea of Eureqa, but it may be necessary to reprogram it from scratch to do the sorts of "mathematical" explorations that we here at math-fun like to do. Even by adjusting the "complexity" of different operations by large amounts, I still wasn't able to force Eureqa to output expressions like nested square roots, or deeply nested divisions (i.e., continued fractions). Eureqa also seems to prefer "simple" constants, and refuses to refine the number of digits of a constant before looking for a more complex expression. There should be some user-programmable mechanism to provide a complexity function for constants.