Complex Numbers - Revision history

Culix: Restoring actual content that was deleted

2009-10-03T02:14:35Z

Restoring actual content that was deleted

Show changes

Spam cleanup script: Cleaning up links to www.lifesmith.com

2009-02-26T01:45:19Z

Cleaning up links to www.lifesmith.com

Show changes

Cope: /* Functions for Complex Math */

2009-01-19T01:00:01Z

‎Functions for Complex Math

Cope: /* Functions for Complex Math */

2009-01-19T00:59:47Z

‎Functions for Complex Math

Cope: /* Functions for Complex Math */

2009-01-19T00:54:40Z

‎Functions for Complex Math

Cope at 00:45, 19 January 2009

2009-01-19T00:45:12Z

Cope: /* Complex Number to Complex Power */

2009-01-16T20:36:19Z

‎Complex Number to Complex Power

Cope at 20:34, 16 January 2009

2009-01-16T20:34:58Z

Cope: /* Polar Form */

2009-01-14T14:48:17Z

‎Polar Form

Cope: /* Polar Form */

2009-01-14T14:36:42Z

‎Polar Form

@@ Line 148: / Line 148: @@
      return pow;
+   }
- float2 cexp(float2 base, float2 ex) {
+  float2 cexp(float2 base, float2 ex) {
      float moduz = sqrt(base.x*base.x + base.y*base.y);
      float thetaz = atan2(base.y, base.x);

@@ Line 142: / Line 142: @@
      return div;
+   }
-   float2 cpow(float2 base, float exp) {
+   float2 cpow(float2 base, float ex) {
      float moduz = sqrt(base.x*base.x + base.y*base.y);
      float thetaz = atan2(base.y, base.x);
-     float2 pow = float2(pow(moduz, exp)*cos(thetaz*exp), pow(moduz, exp)*sin(thetaz*exp));
+     float2 pow = float2(pow(moduz, ex)*cos(thetaz*ex), pow(moduz, ex)*sin(thetaz*ex));
      return pow;
+   }
-  float2 cexp(float2 base, float2 exp) {
+ float2 cexp(float2 base, float2 ex) {
      float moduz = sqrt(base.x*base.x + base.y*base.y);
      float thetaz = atan2(base.y, base.x);
-     float mp = pow(moduz, exp.x)*exp(-exp.y*thetaz);
+     float mp = pow(moduz, ex.x)*exp(-ex.y*thetaz);
-     float2 exp = mp*float2(cos(exp.y*log(moduz) + exp.x*thetaz), sin(exp.y*log(moduz) + exp.x*thetaz));
+     float2 sol = mp*float2(cos(ex.y*log(moduz) + ex.x*thetaz), sin(ex.y*log(moduz) + ex.x*thetaz));
-     return exp;
+     return sol;
+   }
 Notice all the moduz and thetaz calculations are done in these functions, which means we don't need to worry about writing them by hand anymore. All we need to do is pass the two complex variables involved to the function and it'll take care of the rest. Now the full shader_body code for the equation above, '''F(Z) = Z^(2-Z) + C ''', would look like this:
      float2 zoom = 1.5;

← Older revision		Revision as of 00:54, 19 January 2009
Line 164:		Line 164:
	Nice! As a bonus, custom functions don't count toward your instruction limit if you don't use them, so there's no		Nice! As a bonus, custom functions don't count toward your instruction limit if you don't use them, so there's no
	performance difference between using a custom function or writing the calculation out by hand each time.		performance difference between using a custom function or writing the calculation out by hand each time.
		+
		+	'''Important Note:''' cexp() is NOT the same as the function exp(). exp() raises the funny ''e'' to a power, cexp raises one complex number to another. So if you come across an equation that uses e^Z cexp() will not work for it. More on e^Z later.

← Older revision		Revision as of 00:45, 19 January 2009
Line 131:		Line 131:
	* Calculate Z^2Z (complex power of a complex number), store it in Z		* Calculate Z^2Z (complex power of a complex number), store it in Z
	The most important thing here is that we're storing the results of the first and third calculations in a temporary variable. We can't store them to Z because we need Z unaltered for later equations.		The most important thing here is that we're storing the results of the first and third calculations in a temporary variable. We can't store them to Z because we need Z unaltered for later equations.
		+	== Functions for Complex Math ==
		+	Stahlregen found a nice use for custom funtions that can make the shader code for complex math a lot easier to read. We're going to set up 4 custom functions that you can paste into any shader and use in the shader body. The functions will be cmul, cdiv, cpow and cexp. They'll do the same thing as their regular counterparts, except they'll work with complex numbers. Here's the code to define these functions, '''remember to put this before the shader_body statement''':
		+	float2 cmul(float2 mul1, float2 mul2) {
		+	float2 mul = float2(mul1.xmul2.x - mul1.ymul2.y, mul1.ymul2.x + mul1.xmul2.y);
		+	return mul;
		+	}
		+	float2 cdiv(float2 div1, float2 div2) {
		+	float2 div = float2( (div1.xdiv2.x + div1.ydiv2.y)/(div2.xdiv2.x + div2.ydiv2.y),
		+	(div1.ydiv2.x + div1.xdiv2.y)/(div2.xdiv2.x + div2.ydiv2.y) );
		+	return div;
		+	}
		+	float2 cpow(float2 base, float exp) {
		+	float moduz = sqrt(base.xbase.x + base.ybase.y);
		+	float thetaz = atan2(base.y, base.x);
		+	float2 pow = float2(pow(moduz, exp)cos(thetazexp), pow(moduz, exp)sin(thetazexp));
		+	return pow;
		+	}
		+	float2 cexp(float2 base, float2 exp) {
		+	float moduz = sqrt(base.xbase.x + base.ybase.y);
		+	float thetaz = atan2(base.y, base.x);
		+	float mp = pow(moduz, exp.x)exp(-exp.ythetaz);
		+	float2 exp = mpfloat2(cos(exp.ylog(moduz) + exp.xthetaz), sin(exp.ylog(moduz) + exp.x*thetaz));
		+	return exp;
		+	}
		+	Notice all the moduz and thetaz calculations are done in these functions, which means we don't need to worry about writing them by hand anymore. All we need to do is pass the two complex variables involved to the function and it'll take care of the rest. Now the full shader_body code for the equation above, '''F(Z) = Z^(2-Z) + C ''', would look like this:
		+	float2 zoom = 1.5;
		+	float2 c = float2(q4, q5);
		+	float2 uv1 = (uv-0.5)*zoom;
		+	float2 zp = 2-uv1;
		+
		+	uv1 = cexp(uv1, zp)+c;
		+	Nice! As a bonus, custom functions don't count toward your instruction limit if you don't use them, so there's no
		+	performance difference between using a custom function or writing the calculation out by hand each time.

@@ Line 125: / Line 125: @@
 And that's that. The key with the more complicated fractal equations is to break them down into smaller pieces, so for example for the equation '''F(Z) = (Z^2 + C^2)^2Z ''' the process would go something like this:
-* Calculate Z^2 (polar form sin/cos), store it in a new float2
+* Calculate Z^2 (Cartesian form square), store it in a new float2
-* Calculate C^2 (polar form sin/cos), store it in C
+* Calculate C^2 (Cartesian form square), store it in C
 * Calculate 2Z (just 2*Z), store it in a new float2
 * Calculate Z^2+C^2 (just simple addition), store it in Z
 * Calculate Z^2Z (complex power of a complex number), store it in Z
 The most important thing here is that we're storing the results of the first and third calculations in a temporary variable. We can't store them to Z because we need Z unaltered for later equations.

← Older revision		Revision as of 20:34, 16 January 2009
Line 99:		Line 99:

	Flexi also created a nice set of tutorial presets with some examples of fractals, rotations and other uses of complex numbers. Here's the link to the .zip file: [http://forums.winamp.com/attachment.php?s=&postid=2397425 Flexi's Complex Numbers Tutorial]		Flexi also created a nice set of tutorial presets with some examples of fractals, rotations and other uses of complex numbers. Here's the link to the .zip file: [http://forums.winamp.com/attachment.php?s=&postid=2397425 Flexi's Complex Numbers Tutorial]
		+	== Complex Number to Complex Power ==
		+	Ok, here's where things get a little hairy. Suppose you have an equation like '''F(Z) = Z^(2-Z) + C ''', now we're raising a complex number to a complex power. So lets step through it, like most math it's not so hard once you've done it a few times. I'm going to describe the procedure from beginning to end, to give you an idea of how to approach a problem like this.
		+
		+	Before we start we define the regular fractal code:
		+	float2 zoom = 1.5;
		+	float2 c = float2(q4, q5);
		+	float2 uv1 = (uv-0.5)*zoom;
		+
		+	float moduz = sqrt(uv1.xuv1.x + uv1.yuv1.y);
		+	float thetaz = atan2(uv1.y, uv1.x);
		+
		+	First step is to compute the easiest bit, 2-Z. Since adding/subtracting a scalar works the same for a complex number as it does for a normal number, the operation is simply:
		+	float2 zp = 2-uv1;
		+	We're going to skip all the theory behind how this next equation works, it's complicated and I don't fully understand it myself. But if you want an in depth look try [[http://home.att.net/~srschmitt/script_complex_power.html this page]]. The equation for finding a complex exponent of a complex number looks like this:
		+	x = a + bi
		+	y = c + di
		+	r = sqrt(x.xx.x + x.yx.y);
		+	θ = atan2(x.y, x.x);
		+	x<sup>y</sup> = ( r<sup>c</sup> * e<sup>(-dθ)</sup> ) (cos(cθ + dlog(r) + isin(cθ + dlog(r))
		+	First thing to note is that we only need to find modulus and theta for the base, not the exponent. Second thing, the + in front of the isin is ''not'' an addition, it's the signal that this is a complex number. The other +'s ''are'' additions. So lets see this equation in shader code for computing Z<sup>zp</sup> + c:
		+	float2 zp = 2-uv1;
		+	float mp = pow(moduz, zp.x)exp(-zp.ythetaz);
		+	uv1 = mpfloat2(cos(zp.ylog(moduz) + zp.xthetaz), sin(zp.ylog(moduz) + zp.x*thetaz))+c;
		+	So first thing we do is find the bit at the front of the equation, which evaluates to a float1 (a scalar). exp(x) is the built in function for the funny ''e'' and is the same as e<sup>x</sup>. Then we simply plug the right values into the rest of the equation and multiply the whole float2 by mp, which is the first bit of the equation. Notice we're not using any values from uv1 directly, just the modulus and theta we calculated from it. If we get right down to it, this is actually a combination of the polar and Cartesian forms. The base (uv1) is in polar form while the exponent (zp) is in Cartesian form.
		+
		+	And that's that. The key with the more complicated fractal equations is to break them down into smaller pieces, so for example for the equation '''F(Z) = (Z^2 + C^2)^2Z ''' the process would go something like this:
		+	* Calculate Z^2 (polar form sin/cos), store it in a new float2
		+	* Calculate C^2 (polar form sin/cos), store it in C
		+	* Calculate 2Z (just 2*Z), store it in a new float2
		+	* Calculate Z^2+C^2 (just simple addition), store it in Z
		+	* Calculate Z^2Z (complex power of a complex number), store it in Z
		+	The most important thing here is that we're storing the results of the first and third calculations in a temporary variable. We can't store them to Z because we need Z unaltered for later equations.

@@ Line 80: / Line 80: @@
 Which gives the ''exact same values'' as
     uv1 = float2(uv1.x*uv1.x - uv1.y*uv1.y, 2*uv1.x*uv1.y)+c;
 As a final example lets do the equation '''z' = (z^0.5)*c + c'''. Here's the full warp shader code for this equation:

@@ Line 67: / Line 67: @@
 Now we have all the variables we need to put our complex number into polar form:
     float2 uv1 = float2(modulus * cos(theta), modulus * sin(theta));
-'''Important Note:''' This equation is ''exactly the same'' as float2(uv.x, uv.y). That is,
+'''Important Note:''' This equation is ''exactly the same'' as (uv-0.5). That is,
-    float2(uv.x, uv.y) ==  float2(modulus * cos(theta), modulus * sin(theta))
+    float2(uv.x-0.5, uv.y-0.5) ==  float2(modulus * cos(theta), modulus * sin(theta))
 as long as we've done the math for the modulus and theta right. This is very important, because it means once Milkdrop has evaluated this equation we can use uv1 in any of the Cartesian operational rules for complex numbers. In fact you can mix the two forms all you want, as long as they're done in different steps, and as long as you compute modulus and theta in the beginning of the shader code. '''Important Note:''' Any time you change the uv1 values you need to recalculate modulus and theta before you can use it again in another polar form equation.