Data Mining
Here is an evolved code, for a funval=8192*dollar/euro quotient during the year 2003. It's a
posteriori made description of events, which expresses the
current day's data in the terms of already known, USD/EUR data.
Therefore it is not an 100% accurate, but about a percent less. What is
interesting about this evolving techniques is the observation,
that having some other currencies yesterdata, improves the
performance of the code segment. It gets significantly closer with the funval
variable to the actual 8192*dollar/euro
cr=5;
prime+=1;
funval=8547;
two^=4;
if (cr1!=m) {
two^=9;
funval=m^cr1;
one=10;
if (one<cr) {
m+=3;
goto labelcritticall16;
}
if (two!=m) {
funval+=18;
}
}
one=cr;
m=m&funval;
funval+=4;
if (cr1>=prime) {
funval+=36;
labelcritticall16:;
prime=cr1^cr;
}
funval&=5;
In other words, any hidden
causalities or correlations between data pieces are reflected in
evolved code. A very unusual but impressive way of datamining, A
promising test is just under way. Meantime, consider this more academic
and less lucrative example, which can be understand easily:
Suppose that we have to decide, whether a given number is a prime or
not. With enough computation available, we can always tell if it is,
but say we don't have a lot of computation. And that the numbers
given to us, are equally likely to be primes, that they are not. What
strategies can Critticall evolve, to have better than 50% chance to
guess that in less than 100 steps for numbers above 100 million? It is
quick to spot, that even numbers are likely not primes. Than it
consider them for being divisible by 3 ... and so on. But soon,
something more significant than divisibility by 17 appears. It is
about how many binary zeros and ones, this number has. Than do some
computation with this. It is a good way to guess primality  and
Critticall has spotted it. Critticall's algorithm is quite bright in
doing so. Doesn't matter, what kind of data we have  numbers or
money numbers. If there is a regularity at all, it will be found
eventually.
The following code is evolved to be very good in spotting primes, and
we have no clue, what does it doing in fact. As have no idea, why the
above code is good at setting the right values for dollar/euro quotient.
critticall3^=2;
if (num>=critticall1) {
if (p>c) {
p=12;
num+=1;
if (critticall3!=c) {
p+=13;
critticall1=num;
}
number[p]=num;
num=0;
critticall3=0;
p=4;
}
c=1;
c=c#
p^=10;
}
if (critticall3!=c) {
p+=12;
if (critticall1==critticall3) {
number[p]=critticall3;
}
p+=12;
p^=11;
p=pc;
}
number[p]=critticall3;
p+=32;
p=p>>c;
critticall3=4;
number[p]=critticall1;
p=13;
number[p]=num;
Doesn't matter, we are pragmatic here in these probabilistic cases. As
long as the c variable is in 80% right which numbers are
primes, as the funval is very accurate what the quotient
8192*dollar/euro is, we are quite happy about.
What we may wish, are further evolution's results.
