img/home.png

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&num;
        p^=10;
    }  
    if (critticall3!=c) {
        p+=12;
        if (critticall1==critticall3) {
            number[p]=critticall3;
        }
        p+=12;
        p^=11;
        p=p|c;
    }
    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.