Welcome to Fractal Forums

This is the best commercial program for zooming very fast and very deep into the 2d-Mandelbrot.
The program is very easy to use.  Also you can make easy zoom- and iteration-movies.
The program is available for 32-bit- and for 64-bit-operating systems.

This is a little break for the zoom level discussion:

Zooms Magnification Amount Size of Monitor
1 2 bigger than a bread box
2 4  
3 8  
4 16  
5 32  
6 64  
7 128  
8 256 football field
9 512  
10 1024 100-story building
20 ~1E6 Vancouver Island
30 ~1E9 Jupiter's radius
40 ~1E12 Earth's orbit
50 ~1E15  
60 ~1E18 distance to Alpha Centauri
70 ~1E21 Milky Way galaxy
80 ~1E24 large doesn't cover it!
90 ~1E27  
100 ~1E30 huge
110 ~1E33 really huge
120 ~1E36 even huger
130 ~1E39 enormously gargantuan
140 ~1E42 size of electron to the universe
1000 ~1E301 incomprehensibly big...but we did it!
7200 ~1E2167 Maximum zoom level supported by Fractal eXtreme -- at this time.

Anti-aliasing is available.
Take a look at the trial-version.  All you don't get is zooms greater then 100.

http://www.Cygnus-Software.com/ (http://www.Cygnus-Software.com/)

very nice image :)

If you use the theoretical physical minimum length to be observed/measured and take that to measure the observable universe, you'll get to roughly
5.4e61 planck lengths...
Anything beyond that is truely larger than the observable universe :)

yep. that's the reason why the little mandelbrot formula makes every computer system stuck.  :jam:

Good Program.Is very fast render.

The only program I use but then I'm obsessed with mandelbrots.
I just found out that Fractal Extreme .fx files will load directly into Gimp.
Turns out the .fx file has an imbedded BMP at the start.

I make a few zoom movies they're on my Youtube channel, user CommandLineCowboy.
The compressed videos really dont measure up to the quality of watching the zooms using fractal extremes movie player.
I've been wondering wether/how to share the actual .fxz files so folks could see my zooms in all their glory.
I don't really wan't to pay for a file sharing site like rapid share and they idea of setting up a torrent scares me,
letting folks access my computer directly.
Any ideas on how to share .fxz zoom movies?
Is anyone actually interested in them?

You could attach them to a post here.

There's a file size limit on attachments, not sure what it is.  Are fxz files very large?

I just saw this thread & quickly downloade & played a couple min. I'm already addicted.  Too much fun!

I've set up a free Mediafire account.

A couple uploaded so far.
Generally they are a bit bigger than the Youtube video because they have a lossless compression (PNG?)
The zoom player interpolates the video frames, so at 25fps taking 1.2 seconds to do 1 zoom interpolates 28 frames.

http://www.mediafire.com/?9notyrxyoqxf2c9
13.3Mb
for this video
http://www.youtube.com/watch?v=JPPHrteYo9A

and
http://www.mediafire.com/?yadda6444n0c67e
30.56Mb
http://www.youtube.com/watch?v=JKFvfyNJOkQ

& A couple more of my Fractal Extreme Movie Files.

http://www.mediafire.com/?ec2g1n6b6v2am8r
33.6 Mb
http://www.youtube.com/watch?v=smarO-rYkgc

http://www.mediafire.com/?kcwair6hdgxphvv
105.65 Mb!
http://www.youtube.com/watch?v=AlsMKVkMArc

I like to slow down the zoom (- key) to about .82/.85 zooms per second.
Enable the OpenGL and full screen then hit cntrl-s to Spin.
Hit Cntrl-Q about 5 times to slow the spin down, maybe cntrl-A to reverse the spin
Now that makes for a pretty amazing spinning zooming video.
If you don't like the rectangle frame at the bigging showing in the zoom you can f8 to mark
the beginning so you don't ruin the effect.
Sit back, put on your favorite music and indulge in the chemicals of your choice.

I gave Fractal eXtreme a go the other day. But it's a Windows program and I don't use Windows :-( I have Windows on my PC but I just don't ever use it.

Anyway, Fractal eXtreme makes my program MDZ look like a piece of medieval farm machinery :-(

FX is just blindingly fast and my addiction to the M-set is pleading with me to get it.

So, big question, has anyone tried running FX using Wine or one of the virtualization thingymajiggies under LINUX?

Jwm-art, do you use the SSE SIMD instructions for your calculations in MDZ? I guess it depends on the capabilities of the compiler you're using and library support. Unless you wan't to dive into x86 assembler  :vomit:

James,

Fractal eXtreme and UltraFractal both work *mostly* well under WINE.  I say mostly because of FeX's export of anims not, well, exporting.  At least in the test runs I've done, it doesn't do anything and throws an error about pathing.  I'm wondering if it's the CODEC interpretation, permissions, or some other bugger.  Haven't figured it out.  Of course, haven't looked very hard, either...I like both FeX and UF, but even now as I type this, Mandelbulber, Mandelbulb3D and MDZ are the ones running, soooooo....you know... :)

Also, I wouldn't say it makes it look like MDZ look like medieval farm machinery (which doubled as fairly effective weapons in battle, remember!), since they strive to do different things.  I run MDZ for accuracy and real precision zooming (meaning going exactly where I want and getting the proper framing, etc, without doinking too much...).  Still, there's no doubt it's a good proggie -- and worth the price, methinks...or at least that's what I'm telling myself since I purchased it. :D  The other thing to consider is that it has blazing speed until you get deep and need a lot of iterations, then, it's right there with everybody else.  Although 500M iterations may seem excessive, it's how I roll.  :dink:

I've uploaded a few more Fractal Extreme zoom movies.

Doughnuts on a rope
320x240 15.47 Mb
http://www.mediafire.com/?7xe6k9ihy3h3l26
1280x720 166.1 Mb
http://www.mediafire.com/?242sdjaf797uai5
http://www.youtube.com/watch?v=AwHPSpyAEHs

Julia set zoom
336x210 13.78 Mb
http://www.mediafire.com/?c335g6m9jabok89
http://www.youtube.com/watch?v=bJyCQCprdjo


Mandelbrot Zoom Doot Doot
480x360 23.49Mb
http://www.mediafire.com/?o7jnppfc14qgvt7
http://www.youtube.com/watch?v=SUACowTBm2c


Colourful 'furry' mandelbrot zoom
576x360 35.35Mb
http://www.mediafire.com/?o53399o5dco81n5
http://www.youtube.com/watch?v=QeZ80Ca5V4Y

If anyone is interested you can download my Fractal Extreme palette files here.
http://www.mediafire.com/file/2g2taaa2c5k9uu2/FXpalettes.zip
Theres only 223 of them!
My current favorites are f512kyrmwgcbXXintof16 and f512bcgwmrykXXof16.
These are created by duplicating the palette into the stripe palette then ofsetting the stripe palette by 16 places.
Creates a nice stripe affect and blends the colours a bit to get away from the very primary colour look.
Similarly named files have different offsets (the ofXX end of the filename).
Adjust the slider on the colour palette control by one step and this effectively reverses the offset (-16 instead of +16)
by making the 'even' palette odd and the 'odd' palette now even.

I've started a blog for fractal beginners if there are any newb's out there that found this thread :) (Although it will as of now also be a showcase for any and all fractal art I create, so you know, hop on over and check it out even if you're an fractal oldtimer... I'd appreciate some critique.)

http://mandelubber.blogspot.com/

If you're truly new, you should start from the first blogpost in May 2011.

It's been quite an adventure so far, and I've only just begun :D

Has anyone came across a plugin that allows exploration of the Burning Ship fractal in Fractal eXtreme?

I've had a bit of a look at Fractal Extreme's Plugin Kit. It certainly looks doable.
The trick is the absolute function which Bruce Dawson (Cygnus Software) doesn't provide
but can be constructed (in high precision math) from his IsNegative() and FixedNegate() functions.
Apart from that it doesn't seem to big a change from his supplied example Julia plugin.
Just had a look at DeepZoomNet's Burning Ship zoom on YouTube and that's got me interested.
Stay Tuned.

Awesome, I also emailed Cygnus inquiring about this, I'll let you know what I hear back.

DeepZoomNet's Burning Ship video was what got me interested in this fractal, I have been exploring it quite a bit in Ultra Fractal 5, however at any depth where it starts to get interesting, it slows down a lot.

Thanks again for your response.

Here's the plugin I've just created. I haven't even bothered to rename it from "SamplePlugin.dll".

http://www.mediafire.com/?dc442t4r3j3tn7n (http://www.mediafire.com/?dc442t4r3j3tn7n)

Its 32bit only as I have MSVC++ express and that doesn't do 64 bit.
Perhaps some good person could take my source and build for 64 bit if they have the full MSVC?
Source code is here http://www.mediafire.com/?xq0x4emw323cb83 (http://www.mediafire.com/?xq0x4emw323cb83)

Its a bit buggy, it crashed Fractal Extreme on exit but ran okay until then.
It does Julia version and has no limit on the zoom depth.
And its seems to be upside down! I may have added something I was supposed to subtract.
I'll look into that so I may have a new mediafire link shortly.

Awesome, that's a great start.  :D

I'll test it out and give some feedback, Thanks a lot Panzerboy!

edit: ZOMG its soooo fast!!! this is why I love this program.  Maybe you could email this to Cygnus and have them include it in a new update, the Burning ship fractal is exquisite and is a superb addition to any fractal program.

Thanks again, that was very fast, I honestly didn't expect something that quick.

Okay new version, right side up now but is reflected left to right compared with DeepZoomNet's video.

http://www.mediafire.com/?on6in5pb6didawl (http://www.mediafire.com/?on6in5pb6didawl)

Still crashes on exit or closing the fractal window.
I built the sample plugin Cygnus provides and that crashes Fractal Extreme when you try to create any new fractal.
So I suspect the problem isn't my code, possibly the version of MSVC++ 2008 Im using.
Time for me to email Cygnus.

New Source code link http://www.mediafire.com/?ibbs5x3zih6ztad (http://www.mediafire.com/?ibbs5x3zih6ztad)

I can also confirm the crashing when closing the fractal, although its a minor inconvenience as it works great while its still open.

Well I have my next several hours planned out, just need to find a color pallet that looks good   :dink:

I've got a couple of zip files with my palettes on my mediafire account.
http://www.mediafire.com/?kkqdg8djtsbci (http://www.mediafire.com/?kkqdg8djtsbci)
and just uploaded the new palletes since august 2011
http://www.mediafire.com/?ze841xbd0prlrvo (http://www.mediafire.com/?ze841xbd0prlrvo)

Try any that end with 4-8-16 or 4816 for stripey palettes.
Some palettes specify offset striping, so ending with of14 means the odd (stripe) palette is the same as even but offsett by 14 places.
Or GOR4812of20 or the GreyEven palettes for a subtley colour striped greyscale.

I've actually been using your pallets for quite some time now from post earlier last year, thanks for the updated ones.

I see they work especially good for the burning ship fractal, especially once you start zooming towards the center of the mini ships. I'm finding so many cool new areas in this fractal, as I suspected, DeepZoomNet's video really only scratches the surface.

Bruce Dawson of Cygnus has kindly built the plugin under MSVC2010 and the crash problem has gone away.
New link for the plugin http://www.mediafire.com/?sllaetoodr3txg7 (http://www.mediafire.com/?sllaetoodr3txg7)

and now we have a 64bit version too! http://www.mediafire.com/?4w4jc5scv3z2ixw (http://www.mediafire.com/?4w4jc5scv3z2ixw)

I love you guys!!!

I have been exploring this for the last few hours, I had no idea stuff like this existed in the Burning ship.

(http://i.imgur.com/55PVO.jpg)

The Julias do look gorgeous

(http://i.imgur.com/e9PnN.jpg)

PanzerBoy, I would just like to thank you for taking the initiative to do this, and to Bruce Dawson for fixing the plugin (and 64 bits too!) I'm rendering some wild stuff right now, at about 292 zoom levels! I dabbled around previously in the perpendicular Mandelbrot with UltraFractal; the burning ship seems to be similar patterns, in that it is totally disconnected in some parts, and occasionally you get patterns that are skewed, creating elliptical patterns rather than circles. If I render a large enough image, I believe I can fix the skewed effect in post processing with minimal loss of quality. Those who are familiar with my stuff on youtube and deviantart (screenname stardust4ever) may be aware that I have exploited the periodic doubling effect within the Mandelbrot set to create striking patterns of "X" formations which repeat themselves (http://www.fractalforums.com/images-showcase-%28rate-my-fractal%29/magnum-opus-x/), and I'm somewhat curious to the extent at which the Burning ship can be exploited in similar fashion. Ultrafractal is far too slow (32 bits and unoptimised) for me to explore these bizarre formations to great depth.

If fact, sadly to say, in the past when I first saw the Burning Ship fractal zoomed out, it looked like an uninspiring asymmetric mess, but all of that changed a few months ago when I viewed a deep zoom video of the Burning Ship on HPDZ.net

Keep Zoomin' O0

I simply love the speed and ease of use of Fractal eXtreme 64-bit and the Burning Ship plugin is really neat too.

I'd love to be able to copy one of my FractInt formulas and paste it into a text entry field and have it interpreted by a plugin, or to figure out how to get a plugin created for some of my formulas.  Here's one of my FractInt formulas:

simon0020 (xaxis) { ;man on his side
  z = c = pixel
  x = 1/c:
  z = 1/((z+c)^tan(x))
  |z| < 4
}

and here's the initial render it creates:

(image removed)

Anyone have the know-how and ability to create this as a plugin for the 64-bit version?

Simon

Easy enough to do in floating point, you'd be limited to 45 zooms.
It would run slower than the mandelbrot because of the two divides and the tangent function.
Trying to do the same in arbitrary precision would probably be hundreds of times slower.
The Fractal Extreme Plugin SDK doesn't provide trig functions nor even a division for arbitrary precision numbers.
So you'd have to do the divides in slow c++ code rather than Bruce Dawsons fast SSE2 code.
I found an arbitrary precision division algorithm that just used subtractions and additions, lots of them!
Calculating a tangent is an iterative process of its own, each iteration having several multiplications and additions, for a 128 bit number maybe 30-40 iterations?

The only advantage Fractal Extreme would give you over FractInt would be the multi-threading.

I'd use Ultra Fractal. Its floating point gets to the similar depth, and it has all the trig functions and multi-threads.

Thanks for this. I'll try it out.

New plugin for Fractal Extreme.
It includes the Burning Ship with a slight improvement for the Julia's if you zooming in on the Origin (reflecting the real and imaginary axises (axisii?)).
Now includes Celtic and Buffalo fractals plus their julia variants.
To install remove the Burning ship plugin as you can't have two plugins generating fractals with the same name.

http://www.mediafire.com/?c84ep2e281a6bve 32 bit
http://www.mediafire.com/?52ih8j80p2h9oev 64 bit
http://www.mediafire.com/?nimv9h31mp6nwtr Source code

I've removed the Burning ship plugins as this superceeds it.

Decided to create a SourceForge project. Saves having to change mediafire URLS each time I upgrade.

For Burning Ship, Celtic and Buffalo fractals (and Julia versions) download one or more of the files here.

http://sourceforge.net/projects/fxabsmandvar/files/

Hem sorry this was a old post and i had no the patience to see if get a reply along this long tread


In case not i believe the path error come simply by the Linux and Windows path using different syntax :
"/" instead of "\" so should be simple to fix (but since is not a Open Source program fix may be more complex)

Thank you Panzer for generating these fractal formulas. I watched a video of your Buffalo fractal a few days ago and thought it looked fascinating. I also have a small request if it isn't too much to ask; I would like to see the perpendicular Mandelbrot (order 2 Mandlelbulb vertical slice) and the three-armed Mandelbar variation, which includes minibrots as well as minibars within it. It seems while I have a decent grasp of the mathematics involved, I don't know a thing about computer coding (though I did once write a simple TI-Basic program using floating point complex math to draw a mandelbrot on a Texas Instruments Voyage-200 calculator screen, but never published it because it took over 24 hours realtime to draw the set with a 25-iteration bailout - I emulated the results on a PC in a couple of hours time, but on an actual calculator with fresh batteries, the batteries would likely die before the program finished).

I downloaded the zip files, but can't play with these new formulas yet because I'm in the process of rendering a zoom movie. If I attempt to replace the files while FX is running, the results would likely not be pretty.

Is there any chance that Bruce Dawson will upload these fractals to his website or include them in a future FX release? The only third-party plugins I was aware of beforehand were the Serpenski triangles and some packed circles fractal, which looked exactly the same no matter how deep you zoomed.

Sorry for the double post. I installed the 32-bit plugin so it won't interrupt the zoom movie I'm doing in the 64 version.

Here's something you won't find in a million years within the Mandelbrot set: A deep zoom with two minis. Just select the buffalo fractal and zoom into the rightmost tip of the needle. You have to pick a dendrite on the top edge of the needle. There you will find the twin mini-buffalos! This render was done at a modest 179 zoom levels... O0

If this is the mandlebar
http://en.wikipedia.org/wiki/Tricorn_(mathematics)
Then you wont get any advantage from Fractal Extreme's fast arbitrary precision maths.
Fractal Extreme's plugins work in two modes, the first is floating point and the second is Bruce Dawson's 'High Precision' type which can be up to 7200 bits long.
But there are only enough high precision arithmetic functions to do a mandelbrot - multiplication, addition and subtraction.
There are a few other like left and right shift and most importantly for my plugin a negate and negative test so I was able to do the abs() function.
The tricorn does a power of -2, which is like (1/x)/x. Trouble with division is that its a computationally intensive operation.
Check out the clock cycles for any microprocessor and you'll see division takes the most cycles (if provided at all, early ARMs had no division).
With multiplication you can speed up the process by working in parallel, each bit of the multiplier is ORred with the entire multiplicand and then shifted to the relevant position.
The results of the ORs are then summed. The ORring can happen all at once as nothing is dependant, the summing can be sped doing half the additions in parallel and so on.
Division requires the input to be the output of the previous step, to do division its essentially repeated subtraction of the divisor then shifting the divisor down and repeating.
http://en.wikipedia.org/wiki/Division_(digital)
No parallelism is possible. (Okay a GPU could work on many divisions at one time but Fractal Extreme calls the calculation plugin one complex coordinate at a time).
So you'd be limited to the floating point 42 zoom limit, and  for that UltraFractal is just as fast and has much easier customised equations.

I had a look for the mandlbulb and the formula I found has square roots and atan functions.

Bruce has offered to add a link to my plugin on the Cygnus Software web page.

I recall there were two different formulas for the 3D Mandelbulbs. One formula version used trig functions, and the other version used polynomials. The poly functions were much faster for the lower orders than the trig functions (especially 2nd order), but due to the complexity of the higher order polynomial, the trig functions became much faster for bulbs higher than order 8. I'm trying to find some old posts about it here in fractalforums which I remembered reading a long time ago, but the search function is practically broken. I know the polynomial functions did not use trig, but they may have still incorporated a variable "r" where r = sqrt(x^2+y^2+z^2) which would still be problematic. I can't find it, but there is a post somewhere on fractalforums which lists the polynomial equivalents of mandelbulbs for orders 2 through 8. If I can find that post, I can just reduce the set x,y,z by setting y=0 and then reducing the equation to x and z using basic algebra, but I know for a fact there is a polynomial version of the equation which does not use trig functions.

Hi guys

Panzerboy, thanks for the information on what operations are available in Fractal eXtreme.  I have written the following formula in Fractint:


smf-test-03 {
  z = p = (0,0) - pixel
  i = imag(p)
  r = real(p):
  z = z * z + i - r
  |z| < 4
  }

I don't expect for one minute that I have come up with something new (I thought I had the other day and it turned out to be the buffalo previously mentioned above) so if anyone has seen this one before and knows the name of it, that would be useful to know.

Now, I believe this code wouldn't be too hard to turn into a plugin but I simply have no clue about it.  The resulting output in Fractint looks like the following images (successively zoomed in):

(http://www.needanother.co.uk/uploads/fract060.gif)

(http://www.needanother.co.uk/uploads/fract061.gif)

(http://www.needanother.co.uk/uploads/fract062.gif)

(http://www.needanother.co.uk/uploads/fract063.gif)

(http://www.needanother.co.uk/uploads/fract064.gif)

Please could someone take the time to create a plugin if possible (64-bit version) as I'd love to explore this one much quicker.

Thanks in advance.

Simon

I've asked for a new board to be set up for Fractal eXtreme and this has been done.  It has two child boards, one for plugins and one for gallery.

I don't know if it is at all possible but I wonder if this long post can be split (as it has become a bit muddled) and relevant parts placed in individual posts?

Maybe someone could see if it can be done, or is it something one of the users will have to do (copy and paste into several new posts).

Simon

I'm having problems trying to implement this. I've never used Fractint but I found a page giving a tutorial.
http://www.nahee.com/spanky/www/fractint/frm-tut/frm-tutor.html#learn_more_complex_anchor (http://www.nahee.com/spanky/www/fractint/frm-tut/frm-tutor.html#learn_more_complex_anchor)

My code looks like

This results in an interesting shape but nothing like your examples.

Panzerboy.

It's getting closer, but not quite there.

I just can't seem to get my head around converting z = z * z + c into the required arithmetic operations that work on the real and imaginary parts of the pixel coordinates at all!  For example, where does the 2.0 in the middle of the calculation come from?  Just doesn't seem to sit right in my brain.

I've got even less chance of working out how to change the sample plugin code into something resembling my formula.

Ah well, keep up the good work.

Simon

One thing that I found fascinating, was there are a lot of minis in the Burning Ship fractal that look like Celtics, as well, there are a lot of minis in the Celtic that look like burning ships. Because the Celtic Mandelbrot uses the abs(r), and the Burning Ship fractal uses the abs(i), while the Buffalo uses it on both (I think). Because the minis have all sorts of orientations, a mini in one fractal set can have a variety of different shapes, which is fascinating.

Because the positives and negatives behave differently on the real axis, I wonder if -abs(r) would produce something different from the abs(r) formula of the Celtic Mandelbrot, or would it just flip it? I noticed both the burning ship and Buffalo appear flipped on the real axis (needle points right instead of left) compared to implementations in other software. Not really an issue, just an observation.

Panzerboy, you mentioned earlier that the Fractal Extreme software cannot handle arbitrary precision on long division or irrational functions, but it has built-in plugins for fractional and complex powers, which can be calculated to arbitrary precision, albeit much more slowly than the others. Non-integral powers are definitely irrational, as well the sqrt function which is equivalent to a power of one-half, eg sqrt(Z) = Z^0.5

My First attempt was upside down which clued me in that I needed to subtract the imaginary (y-axis) component.
Most examples I found had the bowsprit pointing left so I subtracted the real constant (flips x-axis) as well.

I'll bet that the fractional and complex powers code exists in the MandN plugin.
There's no way for another plugin to access that code.
Bruce Dawson would need to expose the code in a library, as he has done for High Precision Math.

I know I'm asking the wrong person here, but does anyone have any idea what kind of formula the Hidden Mandelbrot uses? It's like it has all the normal features of the Mandelbrot set, but it's full of parasitic cobweb-like structures which really become vividly detailed at higher bailout values (I used 1024). There's also an ugly triangle shape with distorted minis embedded in the cobweb material. It's totally unique fractal I've not seen elsewhere, which is mostly-connected, quite unlike Panzarboy's fxabsmandvar fractals. I'm not at all familiar with x86-64 assembly code, so I have no idea if it's possible to reverse-assemble a .DLL file to look at it's guts. Probably not an ethical thing to do anyway, even if it is possible. :siren:

On an unrelated note, does anybody else use free Avast Antivirus? I noticed that my anit-virus updated the other day, and it flagged the FX main executable and the zoom movie player (both 32-bit as well as 64-bit versions) as potentially unwanted/malicious program and prompted me to open it in a sandbox environment. I selected the "Open normally" option and checked the box to "always perform this action." Kind of a nuisance, but I'm sure it's all on Avast's end. Maybe the new update has an over-zealous heuristics engine? For the record it also flagged a couple of other open-source non-fractal-related software I downloaded as well.

Panzerboy

In relation to your post (#40) and the snakebrot you created, can we have the plugin for that to explore, as it looks like there could be some detail worth zooming in on.

Simon

Hi Panzerboy.

I've just changed my formula to the following:


The resulting shape is:

(http://www.needanother.co.uk/uploads/fract075.gif)

which I think is the same as the one you created.  The only difference is in the lines which create the variables i and r.

In the original formula, the real part of the complex pixel is assigned to the real part of the complex variable r, with the imaginary part left at 0, and the imaginary part of the complex pixel is assigned to the real part of the complex variable i, with the imaginary part left at 0.

In the modified formula above, the real part of the complex pixel is assigned to the real and to the imaginary part of the complex variable r, and the imaginary part of the complex pixel is assigned to the real and to the imaginary part of the complex variable i.

In your code for the plugin, the lines that assigns to zi may have to have everything after * 2.0 removed.

Hope that works.

Simon

Just a thought, but a third-order variety for the fxabsmandvar plugin would be super-easy to create just by editing the source code for the original plugin. HPDZ uploaded a third-order burning ship at one point, which I was shocked to find out it had strait dendrites in it, something unheard of for third-order mandelbrots. Th third-order Burning ship really has a beautiful symmetry to it and would make a lovely addition to the Fractal Extreme library.

In fact, I thought of two separate varieties. Although I'm familiar with the complex math involved, for simplicity and readability sake, I'm not writing out the Zi and Zr components to the equation. absi() means the abs function is applied to the i component; absr() is applied only to the real component; absri() is applied to both.

Standard 3rd order absmandvar:
Burning Ship: Z1=absi(Z^3)+C
Celtic: Z1=absr(Z^3)+C
Buffalo: Z1=absri(Z^3)+C

Hybrid 3rd order absmandvar:
Burning Ship: Z1=absi(Z^2)*Z+C
Celtic: Z1=absr(Z^2)*Z+C
Buffalo: Z1=absri(Z^2)*Z+C

I have absolutely no idea what kind of bizzare fractals these "hybrid" 3rd order variations would produce. I'll need to experiment with creating custom formulas in UF but I don't know how to create fractal presets from scratch. I'm not much good at writing code, but I could take a stab-in-the-dark at editing the source. Is there any free or open C compiler that builds DLLs which are compatible with 64-bit windows? I really don't feel like clunking down a wad of cash for something I'll probably only play with once or twice.

Just to let you folks know, I'm not ignoring the requests.
I'm just having problems with the High Precision versions going blank on me.
Got some bug somewhere.

Hi Panzerboy

I've installed Microsoft Visual C++ Express Edition and the Microsoft Windows SDK V7.1 and using your source merged into the sample plugin I have attempted to compile a plugin in 64-bit, but I get an error about afxwin.h not being found.  I have downloaded and am about to install the Windows Driver Kit which includes the MFC files so hopefully I will be able to compile 64-bit plugins soon.

Any other hurdles to consider?  I don't know if all this Microsoft bloat will cause my laptop to have a coronary but it's the only choice I have if I want to develop 64-bit plugins as well.  I don't know if it's going to work, so I'll post update when all this finishes.

Simon

As promised, an update on my progress.

I couldn't install the full windows driver kit, so I only installed parts of it, and after configuring library and include directories to include all the new files that are required, I was able to compile the absmandvar source you supplied.  Now, I have to try to compile my formula.  Here I go!

Panerboy, in case you didn't see them, I posted some follow-up posts to some of my previous discussion in the plugins thread. Rather than post the same info twice, I'll just link to it:
http://www.fractalforums.com/fractal-exteme/anyone-know-about-other-plugins-available/msg43099/#msg43099

I've got your formula working. Just setting up a Sourceforge project for it now.
Express Edition doesnt do 64 bit, and the 32 bit produced dlls that crashed when the last fractal window using my plugin was closed.
It also prevented and ordinary mandelbrot fractal window being opened, unless there was a window using my plugin.
So you can certainly experiment with Express Edition, and if you willing to put up with 32bit that crashes.
But VS Pro is really the only way to go, just its US$ 799 ouch! Maybe cheaper for Students?

Simon Snakes's Plugin available now on Sourceforge.
http://sourceforge.net/projects/fxsnakebrot/files/?

I've left in a couple of my attempts becuase they look kind of interesting.
Theres also Burning Ship, Celtic and Buffalo variants where these are not simply a rotation.

Why is it that you have to use MS Visual C++? In  perfect world, any C compiler could be used to compile any C source on any platform. I tried to install MS Visual C++, but the installer stopped because I didn't have 2.3Gbytes of free space on the C-drive on my 5-and-a-half years-old 32-bit Core Duo Windows XP laptop that I use for school. It has an 80Gb harddrive, but I stuffed it with junk because I tend to be a pack-rat. So I downloaded Bloodshed C++ compiler from Sourceforge so I could at least read the source code of the FX plugins. The download was only 2.4Mb, so you have to wonder what kind of bloatware Microsoft must have included that makes it nearly 1000 times larger.

I know I'm gonna sound ancient when i say this, but I took a QBASIC class as a kid in the early ninties, and back then, you had a single .BAS file, which could be run directly within QBASIC, or compiled directly into a DOS executable. I look at the source files, and there's .H, .CPP, .LIB and other file types. What do they all mean? If I try to install Visual Basic Express on my large 64-bit rendering machine, what steps do i need to take to compile? And what would happen in I tried to compile the plugin with an open-source compiler, like Bloodshed or something else? I didn't even see a "compile" option in the file menu. If the C++ programming language is based upon a documented, standardized instruction set, then why can't all C++ compilers conform to a predefined standard so that anybody can compile any source using any compiler for any platform?

I know it doesn't work that way, but in a perfect world, it should. Sorry for derailing. :headbatting:

Panzerboy

Well done.  I'm on a learning curve with this too.  You say that Express Edition doesn't do 64 bit.  Well, I've been researching online and I've managed to integrate the SDK and WDK into EE and it now allows me to compile in 64-bit.  Trouble is I still had the same issue you had where it crashes when closing, so I suspect I've done something wrong somewhere, but I'm still learning as I go along.

I've now got several more fractals to explore in Fractal eXtreme.  This will keep me going for weeks.

As they say, you learn from your mistakes, and boy, I've made a few too.  The plugin I created didn't look like either of our initial versions, so maybe this one could be included too.  The code I used was yours from post at #40 with the  + origzi - origzr removed from the assignment to zi (everything after * 2.0 removed).

It's about time more formulas were made available to Fractal eXtreme as, no offence to Bruce from Cygnus Software who appears to be a nice chap, even he could have spent just a few hours gathering together some formulas and creating a plugin to extend the software as it appears users haven't managed to do so up to now.)

Thanks, and I'll look forward to exploring all these new fractals.

Simon

Short answer I don't know. I quite the newbie to C++. But I can make some educated guesses.

At the top of the calc.cpp and calc_fixed.cpp files it includes stdafx.h, thats a MFC header file.
Microsoft Foundation Classes are C++ classes that wrap over the Windows API in a C++ way, ie classes and methods instead of C structures and function calls.
That's a Microsoft owned technology, perhaps it wouldn't be legal for any one else to implement a MFC lookalike.
Perhaps you don't need MFC for these calculation routines I tried removing the stdafx.h but got undeclared reference messages IIRC.

Using a non-microsoft C compiler would most likely have a different calling convention.
http://en.wikipedia.org/wiki/X86_calling_conventions
So If you can find a way around MFC you've still got the problem of MSVC++ (Fractal Extreme) calling functions that may use the stack and registers differently.
There's probably some guru out there that's written some assembly workarounds for this, I haven't found any in my non-exhaustive search.

MSVC++ is the path of least resistance.

There seems to be an issue with your Snake Plugins when the precision jumps from floating point to high-integer. I made a video of the Misunderstood Buffalo, which kinda resembles Kermit the Frog. The eyes are like some type of weird circle-packing fractal. I set the bailout value to 8 because at 2 it clips the fractal. The processor used is an AMD Bulldozer with 64 bits math.
www.youtube.com/watch?v=LFt2pTH_LGA

The aesthetic of these plugs is a little odd as they seem to be lacking of increasing complexity at greater zoom depths, and they seem to be like a desert mostly devoid of minis. I enjoy finding the minis in the Mandelbrot and the abs variations, and though the disconnected abs versions look vastly different to the Mandel, they behave in a similar manner. In several of the new "snake" fractals when I zoom to an inflection point, the precision becomes insufficient in some cases, much like the centroid of a Julia zoom.

I get a "this video is private" when I try to play the Misunderstood Snake Buffalo.
But I think I know what you mean.
I kept the bailout at 2 and zoomed in to that area until the precision changed.
No problem, changed the bailout to 8 and after the switch to 128 the truncated version appeared.
The high precision version must be defaulting back to 2 for the bailout somehow.

Okay found it in calc_fixed.c

   //for (/**/; count < MaxIters && zrsqr + zisqr < OverFlowPoint; count++)
   // We ignore the user-specified overflow point because supporting that adds
   // significant complexity, and potentially some tricky numerical analysis.
   for (/**/; count < MaxIters && !(zrsqr + zisqr).Overflow(); count++)

In highprecmath.h the overflow method of HighPrecMath math class of which zrsqr and zisqr are objects is defined.

   // Do an unsigned comparison against an overflow amount. Doing an unsigned
   // comparison buys one extra bit of precision and is safe because we only
   // call this against the sum of two squares.
   bool Overflow() const
   {
      CheckPadding();
      return m_data[m_precision-1] > FixedElement(4) << (kShiftPerElement - kIntegerBits);
   }

What Bruce is doing here is avoiding converting the floating point bailout value to a fixed point integer.
There would be several steps involved in this which you don't want to be doing each iteration.
It would be simple enough for me to create a Overflow(FixedElement bailout) method,
ie where I pass an integer bailout value

   bool Overflow(FixedElement bailout) const
   {
      CheckPadding();
      return m_data[m_precision-1] > FixedElement(bailout) << (kShiftPerElement - kIntegerBits);
   }

This would be marginally inefficient as I'd have to cast the bailout to an intfor each pixel calculated rather than once when the precision changed from floating point to High precision.
Hmmm, or perhaps I could use the constructor, only called once?
Don't really know much about constructors and destructors, have some learning to do.
It would also be limited to integer bailout values ignoring anything after the decimal point,
that shouldn't be a problem for you.
Ironically Bruce has been blogging about floating point and representing as integer recently.
The real fix will need to decode the 32bit and 64bit floating point formats.
Now in C I'd use the sprintf and sscanf functions to do the floating point to text and back to integer conversion.
looks like thats still available in C++.


I left the various attempts and experiments in the plugin because, why not?
I haven't done much exploring on them but yes the look quite disconnected and thus wont create 'macro-structures?'

BTW I haven't forgot about your request for Cubic Burning ship.

My appologies. When I uploaded the video, I accidentally clicked "private" when I meant to specify "unlisted." Because I was still logged into my youtube account, it showed up fine on my end. I didn't want a bunch of junk cluttering my youtube profile. The link should now work fine for everyone.

I never said I didn't like them, but there doesn't seem to be a real incentive to zoom deeper into the fractal. What I find is mostly sameness. The "Kermit" effect on the Buffalo fractal with the rings of circles was a fascinating twist. But there are a number of fractals outside the scope of the classic Mancelbrot set that benefit from higher bailout values. Usually if that happens, I just input a 4, 8, or some larger integral power of 2. On the custom "Hidden Mandelbrot" formula by Bruce, I used "1024" because the default bailout value of "2" clipped out a lot of the spider web material. Also, a larger bailout can also change the shape of the iteration bands, especially in the needle area. Would simply truncating the bailout to an integer value and discarding the fractional portion solve the problem?

Thank you for considering the Cubic Burning Ship (as well as Celtic + Buffalo). I played around with the Burning ship plugin in UF5, and the third power definitely has a beautiful symmetry to it, which is not repeated though higher orders. FX is just light-years faster than UF5, hands down. Attempting to render videos in other slower software apps (eg, the single-threaded, 16-bit Fractint) reminds me of the Pitch-Drop Experiment:
http://en.wikipedia.org/wiki/Pitch_drop_experiment

I'm not creating anything that looks like HPDZ's Cubic Burning Ship.
To test I did a mandelbrot cubed to make sure I'd got the formula for that part right.
I've uploaded my plugin such as it is onto mediafire.
http://www.mediafire.com/?kkqdg8djtsbci (http://www.mediafire.com/?kkqdg8djtsbci)

Perhaps your Hybrid formula will be more promising.

Thank you so much for doing this. I just did a quick look at the formulas, and these fractals actually look more like what you'd expect from a 3rd order fractal than HPDZ's cubic ship. I had another look at HPDZ's webpage, and I think this information will be quite helpful.

Source: http://www.hpdz.net/StillImages/BurningShip.htm (http://www.hpdz.net/StillImages/BurningShip.htm)

I spent some time reading over the documents on HPDZ's website the other night, specifically the Cubic Burning Ship, and at first it wasn't clear to me whether or not the abs() function should be applied before or after taking the square. You seemed to apply the abs() function after the square, while HPDZ applied the abs() function before.

For your square burning ship plugin, you used: whereas HPDZ used:
HPDZ chose to flip the formula vertically; you chose to rotate the formula 180 degrees by subtracting C rather than adding. For the purpose of analysis, I will be ignoring flips/rotations. Examining the Burning Ship formula used by you, the abs() function is applied to the imaginary part of Z^2. This isolates Z^2 to complex quadrants I and IV on the number plane, keeping Z^2 above the x-axis. Examining the formula used by HPDZ, the abs() function is applied to both the imaginary and real parts of Z₀, prior to the squaring. This restricts Z₀ to quadrant I on the complex plane, however after the squaring operation is completed, Z^2 can exist either in quadrants I or IV. So, without using complex algebra to develop a rigorous proof, it seems plausible that your implementation of the Burning Ship and HPDZ's implementation of the Burning Ship may very well be congruent to each other, based upon the possible range of values for Z^2.

That being said, we have developed two very different approaches to creating a Cubic equivalent of the Burning Ship. Having seen the results of the render tests, it seems likely that HPDZ applied the abs() function prior to cubing Z₀, whereas with our approach, the abs() function was applied after the cube. Applying the abs() function to both the imaginary and real parts of Z₀ will place the final result for Z^3 in quadrants I, IV, or III. Performing the abs() function only to the imaginary part afterwords will place the final result for Z^3 in quadrants I or IV. On a positive note, we have created a new 3rd order plugin that actually looks and feels even more like a third order fractal than the original formulas. The Cubic Buffalo fractal seems especially promising! These are packed with fractal details just like the 2nd order formulas. I'm not entirely sure how to apply the 3rd order Celtic, but I'm pretty sure now that the 3rd order Burning Ship HPDZ used is: or at least that seems highly plausible.

I have attached sample renders showcasing the differences between UF5 and Panzerboy's Cubic FX plugin. Both fractal types (sans rotation) are the identical for 2nd order. UF5 doesn't have a plugin named "Buffalo" in the public formulas library so I don't have one to compare to, but the "Flying Squirrel" mistake and the cubic Buffalo variant in Panzerboy's plugin look especially promising.

Update: I had t return t- school today for spring quarter, but not before I started a new zoom movie on my 8-core rendering machine. The Cubic Buffalo has two needles at right angles to each other, and the intricate details within the fractal have sweeping lines and right angles much like the Square Burning Ship and Buffalo fractals, which transform into beautiful kaleidoscope-like hexagon formations. Stunning! Expect a new Youtube upload sometime this coming weekend, for the Cubic Buffalo in glorious HD, well provided the render finishes, that is! Thanks again, PanzerBoy...

I also uploaded two videos the other day, as an example of what one can do with Panzerboy's original fxabsmandvar plugin:
http://www.fractalforums.com/movies-showcase-%28rate-my-movie%29/aztec-ruins/

Just a little update... The Cubic buffalo zoom movie isn't finished yet. I about 409 zooms out of 469, @1280x720 2x2 AA, and the average iterations is now 15k/pixel, so it's moving along slowly. The Cubic Buffalo has much in common with the HPZD's and Ultrafractal's implementation of the cubic burning ship in that it is symmetric across the diagonal. I believe that applying the abs functions to "Z" prior to exponentiation is key. For simplicities sake, it may be easier to to just include the Julia values inside the abs() function by placing them in the parentheses. This shouldn't affect the bailouts and would be equivalent to doing the absolute value first.

I'm currently downloading Microsoft Visual Studio 2010 Pro. I have discovered that Microsoft DreamSpark offers free development software licenses to students of higher learning, and Visual Studio is one of those applications. I'm not currently sure if the license is good for one year only or forever, but this is my last semester in school. It says the application is 32-bits, so will I be able to compile 64-bit DLLs with it? Panzerboy, when I finally do get Visual Studio set up, I may need some help learning to compile DLLs. I've never used a modern compiler before. I've already downloaded the source to your Cubic plugin and looked at it. If it's okay with you, I plan on experimenting with modifications the formulas. If I can get the Cubic ship formula correct (so that it matches the HPDZ video), I'll add a new formula into the DLL and title it "C.B.S. Final" or something like that, and then send you the new source, if it's okay with you.

Another thing I'd like to add, though you told us to remove the old Burning Ship DLL (2nd order) and replace it with the new absmandvar DLL, I had already produced a couple of FX files and zoom movies, and they won't load without the old DLL, so I had to insert it back in. Now I have two Burning Ships in my plugins. I've been using the new one though for new FX files.

Update: Well, I got MS Visual Studio to download, and MS was nice enough to give me an ISO which they let me burn to a DVD-R to produce an installation disc - best part is, there's apparently no product key or expiry date either - Microsoft must really trust me! :w00t: Otherwise, MS Visual Studio seems extremely full of bloat: about 7.2 Gigabytes worth once it's installed to the hard drive, and I didn't even have to restart the computer... Anyway, I downloaded the source for your Cubic Burning Ship plugin, as well as the Fractal Extreme sampleplugin kit, and I attempted to open them with Microsoft Visual Studio 2010. It seems your source code folder is missing the .sln file. I found the "SamplePlugin.sln" file in the plugin kit from Fractal Extreme, and I was able to generate a 64-bit sampleplugin.dll without any problems (it simply draws the Mandelbrot set). I noticed you did not have a .sln file in your source, so I manually used the "create new project from source files" option to import the folder. I've tried this numerous times with various settings and I have been unable to successfully debug or release a .dll file without generating errors. First problem I solved was that for whatever reason, the .lib files for the 32 and 64 bit maths are not included in the library, so I had to add them manually. After multiple debug attempts, I still do not understand what I'm doing wrong. For the record, I tried deleting the .sln file from the plugin kit and created a new project from the existing files, and it generated the same types of errors, so I must be doing something wrong when I try to generate a new .sln, or is it even possible to build a new project out of the existing source and compile successfully without the original project file? Confused...

Update 2: Wow, I figured it out! Just when I had given up, I go to the fridge and open a couple of :beer: :beer: :beer: to take my mind off the problem (if your under 21, don't try this). I won't say how many I had. Anyway, my gut feeling had been telling me all along that (abs(Zr)+abs(Zi)i)^3 + C was the correct answer. Suddenly, I get a brainstorm and rush to the computer to edit the sample plugin code in calc.app that I know is compilable. That's with the abs function applied to both the real and imaginary axis. And the buffalo fractal is with the abs function applied to Z^3, again on both the real and imaginary axis, just like the plugin. Well, my cubic burning ship hack job on SamplePlugin.dll works, at least until I hit 45 zooms when it changes back to plain vanilla Mandelbrot! The sample code I edited in the screenshot (highlighted in green) is highly unoptimized, but it works. At least now I've got something that resembles HPDZ's and UF5's plugin version...

:toast:

The new Cubic Burning Ship plugin is live at Sourceforge now.
Looks like HPDZ's finally.

http://sourceforge.net/projects/fxbship3/files/

I removed the .sln and lots of other Visual Studio files because they caused me problems with VS 2008 Express.
The way I create plugins is to take a a clean copy of the SamplePlugin files, removing all .sln, .vcproj and other VS files.
Leaving, the .cpp, .h, .lib, .rc, .rc2 and .ico files.
Then File -> new -> project from existing code.
Accept the project type of Visual C++
Browse to the project location, I usually select the directory immediatley under Projects.
Give the project a name, subfolders should be ticked.
On the Specify Project Setting dialog, drop down to select Project Type of Dynamically linked library.
Tick the Add support for ATL and add support for MFC.
I Next through the Debug setting and Finish at the Release settings.
I select the Build -> Configuration Manager and drop down under Active solution Configuration to Release.
Debug build dlls crash Fractal Extreme so I don't bother with Debug builds
Drop down the Active Solution platform, if X64 isnt shown we need to add it so select New.
X64 Should default in the New Solution Platform dialog that pops up so ok to accept and close configuration manager.
I set the optimization for both Win32 and X64 platforms at the same time.
Project->Properties, drop down platform to select all platforms.
Now Expand the tree for Configuration properties and C/C++ and select optimization.
I Set optimization on the right to Maximize speed.
Inline Function Expansion to any suitable.
Favor Size or speed to Favor fast code.
and Apply.
Now we need to add the mathhelper library which is two versions for Win32 and X64 so drop down Platform to Win32.
Expand Linker in the tree and select Input, in Additional Dependancies type in Win32\FXMathHelper.lib then Apply.
Drop down platform for X64, the linker input should still be slected to into Additional Dependancies type in X64\FXMathHelper.lib and apply.
Ok to close the project properties dialog.
A build new should build


And that all you need to do  :dink:

Sorry about the renamed dlls not supporting the old equations.
Theres an equation identifier in the .fx file that needs to be found in the plugins.
Unfortunately just changing the text with a hex editor won't do.
There will be Header size somewhere in the .fx file that needs to be changed when the size of the text identifier changes.

Hey, thanks for taking the time to do this. Now I can really appreciate it even more having dabbled around with coding. There's a lot of hidden work to writing code that I simply just don't understand yet. Especially, the calc_fixed.cpp portion of the code is not as friendly to read for humans, but really the integer portion holds most of the meat required for deep-zooming. Creating plugins for Fractal Extreme is probably not a beginner project, anyway. I will probably need to find a good reference book on C++ and Visual Studio. Then I may try to tackle the perpendicular Mandelbrot formula sometime.

It's probably more trouble than it's worth, unless you're trying to tweak an old .fx file that took days/months of rendering to pull off. I'm assuming that completed zoom movies should open in the player just fine; you just won't be able to use the "explore from here" tool. But that's the kind of situation you run into when trying to beta test stuff. As long as the coordinates can still be copied into notepad and saved, it's good. My Cubic Buffalo zoom is on frame 443 of 469 and the iteration bands are starting to get denser (it's now taking 1 hour 20 minutes per frame), so it shouldn't be too much longer.

The Celtic version is still not right either, but it is close.I'm still trying to wrap my head around why the UF5 version differs from your version.
UF5 code raises Z to the nth power, then subtracts real Z from Z, before re-adding the absolute value. Despite being poorly optimized (like most of the UF5 code), it's still just taking the abs() function on the real component of z^n, so I don't really know why your second order function is identical to it but not the third order, as unlike the Burning Ship fractal, the implementation method used here appears to be the same. UF5 uses "-C" instead of "+C" but all that really does is flip the fractal 180 degrees.

Update: It has been a very productive weekend for me.

I looked up the formula for the Perpendicular Mandelbrot in Ultrafractal. The Perpendicular Mandelbrot formula is pretty straightforward; it is created by taking a vertical slice from the 2nd order Mandelbulb. While the original Mandelbulb formula used trig functions, the integer power versions of the formula can also be represented as polynomials. Originally, this was worked out through some convoluted system of triplex algebra Z{x,y,z} where x and y are the real and imaginary components of the Mandelbrot set and z makes up the vertical component of the Mandelbulb.

Despite the polynomial form of the equation (which I still haven't located yet, not that it matters) having a square root function, it is found somewhere within the variable r the form r = sqrt(y^2+z^2). Because the Perpendicular Mandelbrot ignores the y axis completely, all of the y's are set to zero and cancel out of the equation, which simplifies out to r = |z| (or something similar to that), eliminating the square root entirely. The solution to the convoluted triplex algebra system is really beyond the scope my understanding, but with all the y's completely removed from the equation, it basically works out to:

Zi₁ = |Zr| * Zi * -2 + Ci
Zr₁ = Zr^2 - Zi^2 + Cr

as the formula for the perpendicular Mandelbrot. If you remove the abs() function from Zr, you get

Zi₁ = Zr * Zi * -2 + Ci
Zr₁ = Zr^2 - Zi^2 + Cr

which is the formula for the Mandelbar / Tricorn fractal. The Mandelbar / Tricorn fractal is quite fascinating in that about half of the minis are Mandelbars, while the other half of them are Mandelbrots. The main difference between the Mandelbar / Tricorn formula and the Mandelbrot formula is for the imaginary portion of the equation, Zi*Zr is multiplied by -2 instead of 2. This inverts the imaginary values after every iteration, creating the three-armed pattern instead of the bulbous Mandelbrot. I have also taken the liberty of creating Celtic variations on both the Mandelbar / Tricorn and the Perpendicular Mandelbrot fractals, as well as Burning Ship and Buffalo variations on the Perpendicular Mandelbrot. For the Buffalo and Burning Ship versions, the abs() function has been removed from Zr and applied to the Zi component on the Zi side of the equation. I did not do the Mandelbar variants of Burning Ship and Buffalo because those are identical to the Mandelbrot variants. So without further ado, I have attached samples of the C++ code that I used for each fractal, followed by sample renders (this time they were all rendered in Fractal Extreme). I'm not ready to create plugins yet, because I still have some learning to do, and I don't want to release crap plugin code that doesn't work well. I may need some help with the "IsNegative" command that Panzerboy used to apply the abs() function within the arbitrary precision portion of the plugin (the code in fixed.cpp still looks like greek to me). I can't install MS Visual Studio on my Laptop because I don't have enough free space on my hard drive, and I've got classes Monday through Friday at the university (pretty soon, I will be loaded with tons of homework as well), so I likely won't be able to work on code except on weekends, and my fiance was more than a little upset with me for being tied to the computer the whole time I was home. :-* :sad1:

people make up new threads for new formulas .. :(