> [ big message about plugins and whatnot snipped :) ]
>
> I'm currently working on writing a fast arbitrary precision float class for win32... I will probably implement it as an MFC extension dll, to make things easier for the end user. Interested?
Pete,
depends on whether you could write it to comply with Steve Ferguson's and my plug-in spec. I'm not sure how it would fit into a formula dll or a render dll. You'll have to brief me on the basics
of arbitrary precision and how it relates to fractals. It's not something I've coded before. Are you referring to the kind of precision switch that Fractint started out with to switch from
integer math to floating point, or a precision switch to support deep zooming? Steve and I are using double precision in our v1.0 plug-in spec. There isn't a basis for using any other precison
in our current programs(since neither of us does much deep zooming.) Maybe arbitrary precision could be used transparently in the plug-in, with the results returned as double, if that had some
use. We've had some trying times to get our spec together, because of individual coding preferences. Both of us had to make compromises, and one of them was that the common data types include no
unions, which would be necessary to support both double and long double in the same variable.
Our plug-ins aren't specifically written as MFC extension dlls, as they work with any 32-bit program. I guess you could call them extension dlls though. I code only in C++ compatible C, until I
learn MFC, while Steve has a lot of MFC experience. You should probably talk to him about MFC details.
I'm going to try to make some time to start a Fractint plug-in, at least for formulas, since I probably know that end of the Fractint code enough to use it. Then there might be some interest in
I'm happy to be given the chance to contribute to the Fractint legend, and at the same time get better aquatinted with what has been one super bunch of programmers. Hopefully noone was seriously distressed by the "platform wars" that I inadvertently initiated on the fractint list. That was mainly a wakeup call, to see what kind of stuff the Fractint team is still composed of. Unfortunately, the responders weren't who I expected, and the platform biases I have seen over and over since Windows was first introduced.
Before we go any further with a joint project, I'd like to introduce myself and say a little about my involvement with fractals and main programming strengths and weaknesses. For those of you who haven't browsed my Geocities home page, I'm an incorrigible Alameda poet who's been married for 18 years and has three teenagers for offspring. My main source of income is a mailer's job at the S.F. News Agency in Union City, California. I've been dabbling in fractals since 1984, beginning my first major fractal program, ZPlot, on an Amiga computer in 1988, about the same time Fractint was being born on the IBM pc. All of my fractal programs
have been windows based, with a heavy stress on algorithms gathered from the classic fractal texts of the time such as Mandelbrot's Fractal Geometry of Nature and the Springer-Verlag books by Pietgen/Saupe, etc. With my first fractal program I wanted to go much further than anything that had been done before. I was taking college algebra at the time, and my professor was very helpful in orienting me to the complex math that enabled me to provide support for almost all complex math functions. The parser I developed at this time may have come out of the programming courses I was taking, but it was largely a product of my imagination, and
limited to interpreting an integer array of op codes. Later I learned to optimize it more in pre-compiling down to function-pointer calls, but the Fractint parser still exceeds my best efforts by far. I've managed to make my parser compatible to a large degree with Fractint's 19.x parser, by browsing the public domain pars and source code for Fractint. Along the fractal way I've taught myself some differential calculus, coded quaternion transcendental math and extended my initial 2D complex math to 4D using the hypercomplex extensions described in Fractal Creations, the second edition. So you might gather that in programming math is one
of my strengths, plus the tenacity to figure out other peoples source code. I don't use any code unless I've been given permission by the author. With all my experience in coding fractal algorithms, I could still stand to learn to use C++ and MFC. I know what is C++ compatible, but I haven't written any programs in C++. One other thing about me, if I have your ear thus far: it may seem at times I am wordy and rambling, and some of that may be due to my poetic leanings, loving words and all that. More important, I like to be complete in my messages to avoid a lot of explanations later. It does no good to start in on something that
people have no reference point for, as Peter did, when he assumed I knew all about arbitrary precision. Enough about me.
Before I can gage what help I can give to the Fractint team, I need to know who is supporting what in the Fractint code, and if there's enough support/breadth there to make the port to 32-bits possible. Introductions would help. I can say now that I have downloaded the code for Fractint 19.6, and with some quirks recompiled it with MSVC++ 1.52. I'm not sure if that is going to buy me anything, since only the makefrac.bat file seemed to work to compile the source. I still can't use my debugger to step through the code in areas where the program flow might be useful to follow. With the large number of globals in the code, it's hard to
determine just what variables a function is dependent on, or what is really being returned by a function. Not always, but without the debugger it's plodding to trace the code manually.
