AI and Mandelbrot Calculations One of the things I found out a few years ago as an electrical instructor teaching at nuclear power plants was that the largest barrier to people learning something new was fear of the unknown. To these older electricians it was fear of the mysterious something called a sine wave and the complex intricacies associated with the field of higher mathematics of algebra. To those of us in the younger generation this may seem inane, but to them it was deadly serious. These were things they had not been exposed to before and many of them felt it was beyond their capability to ever learn or understand. Phooey! I am happy to report that this is never true. Even those individuals who are much slower than average have the capacity to learning EVERYTHING about ANYTHING, only in some cases at a slower rate than others. The very first step in learning is something new is believing that you can. The subject of AI brings out these same fears in many people - the strange mysterious something called pattern recognition associated with the field of higher computer science of Artificial Intelligence. Relax! It really is very simple and easy to understand. After you see what's going on you'll probably ask yourself "Why didn't I think of that?". "An intelligent program is one that exhibits behavior similar to that of a human when confronted with a similar problem. It is not necessary that the program actually solve, or attempt to solve, the problem in the same way that a human would." -from 'Artificial Intelligence using C' by Herbert Schildt, Osborne McGraw-Hill, 1987, p. 11 Keeping that in mind, run the program called SMART and watch it operate for a while. This compiled version of FRACAI.C picks a random point on the screen and displays the successive iterations used to determine if it belongs in the Mandelbrot set. Have a cup of coffee, sit back, and see if you can figure out the criteria the program is using to decide if it's time to move on to the next point. Now press 'Esc' and the program will exit after it is done the current point. Run the program called STUPID. The only difference between SMART and STUPID is the variable 'IQ' in STUPID is set to zero. This means the program does no pattern detection and goes strictly by iterations before moving on to the next point. Let it run for as long as you can stand to watch it. Had enough? Ok, go ahead and say it, "You STUPID program! Can't you see that your iterating on the same dumb points!?" And in truth, no it can't. What happens during the calculation is that sometimes 'i' and 'j' converge onto one or more points and gets caught in and endless loop of successive iterations producing the same 'i' and 'j' combinations. Once it can be seen that the points have converged into a pattern there is no need to continue iterating. Nothing to it! Run the program SMART again and we'll continue. Have you got a printout of FRACAI.C handy? Good. Now, let's see if we can think of a way of detecting the condition where the iterations converge on one point. Easy, right? You just look to see if the 'x' and 'y' are the same as the 'Lastx' and 'Lasty' for five success loops. If so, then it's a pretty good guess that 'x' and 'y' will stay the same for all successive iterations and it's Ok to move on to the next point. We've determined that this point has a periodicity of 1. For a convergence onto two points, A and B, it's a little different. In this case the iteration moves back and forth between A and B over and over again. Let's set 'Lastx' and 'Lasty' as the coordinates for point A. Every other iteration will produce these same coordinates. If after 10 iterations we see that point A shows up every other time, then we can guess that this 'i' and 'j' has a periodicity of 2. The same applies for a convergence onto three point A, B, and C. Let's just pick a point, say B, and set 'Lastx' and 'Lasty' to the coordinates for B. Now every third iteration will produce the coordinates for point B. Here's the kicker: in order for successive iterations to keep coming back to the same point B every third iteration, then the iterations would HAVE to have gone through the same points A and C each time. There is no need to keep track of the values for A and C since the iterations must be producing the same A and C values each time in order to get back to point B. So if it does this five times in a row we can safely guess that this 'i' and 'j' has a periodicity of 3. The same applies for higher periodicities. Pick a point, any point, and see if the iterations repeatedly come back the that point at a fixed interval. If after a bit you don't see a pattern then you can assume that the iterations have not converged yet. In that case we've already gone through a number of iterations and maybe it's converged into a pattern that doesn't include the point we chose earlier, so pick another point. This point picking process is determined by the variable 'CheckEvery'. This has to be a dynamic variable. If it is set to a small value the program exhibits the characteristics of impatience. If you keep it at say the value of 5 and the pattern has converged into a periodicity of 6 then every fifth iteration it will say to itself "No pattern here, pick a new point" instead of being patient and waiting for that sixth iteration. To large a value and the program is very stodgy. If 'CheckEvery' is set to say 2000, and it picks a point not in the pattern, then the program will go through 2000 iterations before picking a new point thinking that maybe it's just a very large pattern. The implementation I've found for far that works best is to double the value of 'CheckEvery' whenever it picks a new point. This catches the small periodicity patterns right off the bat and quickly expands it's scope to catch the larger ones. In theory there should be no need for an iteration limit in the calculation process since the calculations will always, after some period of time, either cause the program to bail out on overflow or detect a convergence into a pattern. In practice after a certain number of iterations I really don't care if a particular point converges or not, I just want to get on to the next point. You'll probably have noticed that I've been comparing points on the screen rather than using the actual values of each successive 'i' and 'j'. There is a very good reason for this. Of the 15 significant digits available in a double value roughly only half of those digits are significant after many calculations due to roundoff errors anyways. Besides, if I get a convergence that is beyond the resolution of the video display then that's close enough for government work! In the assembly language implementation it is easier to just look at half the significant digits rather than to bother rounding off. So the assembly language algorithm just compares the new values of 'si' and 'di' (the high word for the 32 bit 'i' and 'j') to the previous ones and treats these the same as it would for points on the screen. So that's it! If anyone has any questions, I would prefer if you would address them to me through the CompuServes's Microsoft C programing section. Remember, high sounding concepts will only be as intimidating as you let them. Have faith in yourself and your ability to learn and I'll guarantee you won't ever let yourself down! -Mark C. Peterson, [70441,3353] 128 Hamden Ave., F Waterbury, CT 06704 (203) 754-1162 (voice) Note to you corporations out there: I do computer consulting work in addition to custom written computer training courses. Give me a call! 