misidentification

So there formed a problem with my program, and I didn't catch it because it was in a area that was pretty solid. So my program has the possiblility to die... ie no growth in population fitness. This could happen if the population zero is bad. The problem was that all the runs had the same population zero... or so I thought. I manipulated my popZero class so that its population is not mixed and is in order... this is not a problem, its like when you eat do you start from left to right, up to down bla bla bla... I found that some of the individuals read from the PopZero file spawned  genes from nothing. I saw very closely and it turns out that the scanner reads the line, but sometimes forgets what line its on and reads a gene above or below the line. for example the file is
a b c d e f
g h i j k l
m n o p q
 and you want the g line. the scanner might be like oh  here--- g h i j k l
but it might make a mistake and be like --- g h c d p l
Its hard to read just one line it seams. So this error introduces randomness in the program form the start.
I think its cool... in a ha ha weird way. The thing is now how to fix it. I guess read a line over and over but Ill work it out.

Ps. I was tired of editing the file for the runs so I made a ui that asks for all the params, the runs it itself. and when the run is done it ask if you want a rerun.  Work as smart as you have to


P.s.s
I found the problem, turns out that the way I was saving the float arrays where mixing randomly. I still dont know why, but I changed to strings being passed, Ill see how it goes

explination

So since Monday i have not been making post. This single post will encompass all the events up to this point...
---------------------------------------Monday------------------------------------- (^_^)
Ran simulations for point .6-.8 mutation rates on 20 threads. Also tested out continue class, all done on either imp or hornet... both are an 8 bit so the results could be comparable.
--------------------------------------Tuesday--------------------------------------(n_n)
The continue class has a bug, I knew because I put it there... it had a good property... all I need to do is find a way to save the property but not the bug.
The test results were coming in but all the results from hornet where 0.0 or -0.0. nearly all the results from imp where 1.0E-4. Dr. Remy and I walked through what could be happening and ran a another test with, to test the machine, so the same run was ran on joey, imp and hornet. And I was to manually run the test again on joey.
------------------------------------Wednesday-------------------------------------(-_-)
Results came in and hornet for what-ever reason only returns 0.0s, imp works for about 1 generation and the finesses return a default value. joey was the only one that performed okay. So I ran .6-.8 again on joey, .6 and .7 I used 10 threads but for .8 i used 20... just to see if it was a work load thing.
later that day I came back and all where running. .8 had a weird pattern where everything was okay but the second to last 10 finesses in the entire generation was a time out default, in each generation. I kept it going to see the effects,
----------------------------------Thursday-today----------------------------------(U_U)
for some reason, there is timeout values popping up here and there in every run. in the 20 threads the time out happens in the third run. in the 10 threads time out happens in the fourth run. This means that I will have to do some alterations to the code to allow for a longer wait time, or run  the evaluations with 10 threads which kinda defeats the purpose of a quick evaluation. Anyway Im just running the evals in small batches to see if the results are good

guesstimation

Right now Im running/going to rerun 20 iterations of GA with mutation rate of .6, .7, and .8. There was only one successful run of these so not much data will have to do to waste. If  these run dont snag on anything I dont really know what to expect from the data. From what I have seen I would think that the .6 would have one of the higher averages and maximum finesses. Of the runs that completed, it looks like around 50% mutation rate is a point where fitness peaks and then falls.

This could be speculation, I have not done as many iterations as would have been appropriate, It would be quite interesting to see that final charts for this experiment. Some papers that I have read said that a large population in relation to mutation leaves a generation of better configuration, so much fascination...( /\ ./\) on a roll...anyway, some papers said that a smaller mutation rate would be good with a high population.. high meaning 16 , but this also meant a smaller chance for finding a good solution. With the parameters like 100 population and generation then it could also be that the mutation rate might level off at some point.

synchronization

I was able to finally complete that classes that enables a run to be continued if it is interrupted. Its not much but I was able to successfully run this class that started a run from start to finish and to continue where the run left off. If this program work on large scale all the data that was received before can be put to use, the only thing is that a header file will have to be made for each run, but that wont be much of a problem.

alleviation

Finally the problem might have been caught... might.  Dr.Remy and I ran a sample run with 60 threads and saw that the system average load was increasing to a max point of 8 or so. So the computation was stopped... by me so no prob... and reran the program but with 20 threads instead of 60. The average load didn't go past 5.. This was good. So the prevailing theory is that when the computer was running with 40+ threads, it was working as fast as it could on this one process. But when another program was run, by someone else on campus, the computer didn't could not think of what to do...so it stopped. When 60,70, and 100 threads where used the computer couldn't handle it so it would take longer to complete the task, or just stop altogether. So as of now, I'm going to work on the continuation class, and rerun all the mutations again but using 20 threads.

devastation

The problem still eludes me, but for some reason there is a snag in the program... at least in one of the programs being used. I thought that the problem was the readTimeout I added, turns out that this lead to another problem. So as of now the reason that my computations stop was because of X, a thread would wait for some data that did not come and would halt the program. this was "fixed" by adding a readTimeout, if the connection didn't give a value then it would return some value...0.19283746... this lead to nearly all the outcomes being some default value, either on my programs end or on the evaluation end. So Dr.Remy and I worked through what might be happening while another run was being processed. Not much could be done with out the data from this run....It came in, this run was time based so the data is still valid... I had  a looked at the end results for the computations and it looks like the default value doesn't show up until some point and then is a present throughout the rest of the evolutionary process...(>_<)

deviation

I don`t quite know the exact reason why, but for some reason my program stops running after a while. I know where the problem lies, but it is more of an effect then the reason. So my program sends out threads to have a individual evaluated using different ports. Then when the threads return...all of them... then the program continues. The problem is that when a call is sent to evaluate a individual the call is sent to another program...called lets say eval.... Eval then call another program... lets say called show..., show then returns and eval returns with a number. My problem is that if a snag appears on eval to show, or show to eval, my program just sits idle. I added a connection time out but didn't realize that this did not count for actual time for the connection. I added a readTimeout and Im going to see if this works.
I am also making a class that will be able to work with the bits of data that a unfinished run leaves. As the run goes on each generation is saved along with its fitness. All I need to do is make a class that with the base name given, reads the left over file and continues where that calculation left off. Im running into a snag thou... well not a snag more of a moral memory decision . The file could potentially be very large and it would do to read the file over and over for each need. I don`t know of another easy way that I could read the file so that I know which generation was the last, with out altering the file in questions syntax, without reading the file once, then again to get the values of the last done generation, and then once more to adequately read all the fitness, sort them into the appropriate generation and also find the max and average of each generation. At least not all in one single method or function. But im working on it, as of now im just going to try to run an evaluation just to see if the readTimeout worked.