� �
Fractalization is an invented term used to describe a technique of generating pictures. It also provides an easy way to generate stereo pairs. All of the pictures of the month for both July and August are fractalizations.
The stereo pairs in this months picture of month were easy to create and require only a little extra time and effort over the original picture. This technique of generating stereo pairs is apparently original. An infinite number of easily created stereo pairs are possible, once an understanding of the fractalizing technique is mastered.
�
This technique of "fractalizing" formulas can produce pictures with an uncanny beauty. Fractalizing is a term we have coined for an algorithmic technique of rendering fractals. It also applies to a class of equations. The term fractalizing was used because it is possible to take a picture generated with an equation and to redo it as a new picture that has been fractalized. The original equation serves as a generator for the future equations.
Fractalizing is a pixel independant technique of generating fractals where the color value calculated at each pixel is not dependant on the values of surrounding pixels. Pixels may be colored in any order. The most popular techniques of generating the Mandelbrot set are pixel independant techniques. At each pixel on the computer screen a value is calculated. This value is a function of the X and Y coordinates of that point. The single value returned from the function of X and Y is used to color the point. All of the formulas described here use this technique.
For any picture generated this way, we need to specify certain values. In particular we need to know the coordinates of the viewing screen. These coordinates can be any points in the real plane. For some kinds of pictures (like Mandelbrot sets) the interesting area of the plane is limited to a small portion of the whole plane. (such as inside a circle with a radius of two for the Mandelbrot set.)
We will use XMAX and XMIN to represent what part of the two dimensional plane we are interested in. In particular XMAX and XMIN will be used to represent the maximum and minimum X values on the horizontal axis of the computer screen and YMIN and YMAX will be used to represent the minimum and maximum values on the vertical Y axis.
�
The technique of fractalization is based upon what we call a template. A mathematical template is not drawn on the screen but is generated mathematically. For example the expression (X*X + Y*Y) > 25 divides the plane into two parts. The expression evaluates to true for those parts of the plane outside of a circle with a radius of five, whose center is at the origin of the plane, and it evaluates to false for all parts of the plane within the circle. The square root of 25 is five, we get this as the radius because (X*X + Y*Y) > 25 is equivalent to Sqrt(X*X + Y*Y) > 5. Where Sqrt() is the square root function. This expression can be used as a template to separate the plane and plot one set of values within the circle and another set without. For instance:
IF (X*X + Y*Y) > 25 THEN
COLOR = 1
ELSE
COLOR = 2
ENDIF
In the above formula two different colors are used to plot inside and outside the circle. One could equally well replace the 1 and the 2 in the equation above with a formula.
IF (X*X + Y*Y) > 25 THEN
COLOR = F(X)
ELSE
COLOR = F(Y)
ENDIF
Assume we have 4 color registers each with a different color, then the following formula will produce a picture with horizontal lines inside the circle and vertical lines outside the circle.
Let XMIN = YMIN = -10 and XMAX = YMAX = 10 when calculating this formula. Calculate it for every pixel on the computer screen.
IF (X*X + Y*Y) > 25 THEN
COLOR = X mod 4
ELSE
COLOR = Y mod 4
ENDIF
�
Where the "mod" operator is the binary modulo operator.
The function X mod 4 creates vertical lines and the function Y mod 4 creates the horizontal lines. This is a fairly simple template. It divides the plane into only two parts. It is possible to make templates that are considerably more elaborate. For instance, in order to divide the plane into multiple concentric circles we could rewrite the formulas above as:
Let XMIN = YMIN = -10 and XMAX = YMAX = 10 when calculating this formula. Calculate it for every pixel on the computer screen.
IF ((X*X + Y*Y) mod 8) > 4 THEN
COLOR = X mod 4
ELSE
COLOR = Y mod 4
END IF
�
Several parameters are changed in the example. First notice that we find X*X + Y*Y modulo 8. This effectively divides the whole plane into concentric circles. We also used > 4 instead of >25. This changes the width of the concentric circles. The main feature to observe is how using the expression ((X*X + Y*Y) mod 8) > 4 divides the picture into multiple sub pictures thereby creating a template. Here are the formulas for several different kinds of templates.
�
�
�
�
One can think of a fractalization as being a series of cutouts from paper or cardboard arranged in a stack so that the ones that are further away are seen through the holes in the ones that are closer. We form a fractalization by creating a template (a cut out). Each succesive template is based on the preceeding one we created.
�
Fractalization is a set of functions and a procedure for applying them. As in the Mandelbrot set, we will apply the formula at each point in a plane (a plane is 2-space, a line is 1-space. We could do this in n-space.) and the resultant value will be the value of the 'fractalization' at that point. We make no restriction upon the number of variables in the functions except to require that they be the same for all the functions that make up the fractalization. We will call a function of n variables a function of degree n. In an nth degree fractalization all of the functions are at least of degree n. We will use the following symbols:
Define f(X1,X2,...,Xn) to be:
IF t(X1,X2,...,Xn) THEN
RETURN( c(X1,X2,...,Xn) )
ELSE
RETURN( f(m1(X1,X2,...,Xn),m2(X1,X2,...,Xn)...mn(X1,X2,...,Xn)) )
Notice that this is a recursive definition.
This definition can be rewritten in more compact notation by replacing the values of X1,X2,...,Xn with an n-vector x_, and a transform G() that maps n-vectors to n-vectors. The transform G() is used to encapsulate the concept that each of the new variables in a recursion can be a function of any or all of the old variables.
G(X1,X2,...,Xn) = m1(X1,X2,...,Xn),m2(X1,X2,...,Xn)...mn(X1,X2,...,Xn)
We use the function G() to make our notation simpler. Do to the limitations of HTML, we, will always subscript variables used to represent vectors with the underline symbol "_". "x_" is a vector. The fractilazation f(x_) is then defined by:
Define f(x_) to be:
IF t(x_) THEN
RETURN( c(x_) )
ELSE
RETURN( f(G(x_)) )
f() = { t(), c(), G() }
The fractalization is defined by the set of the two functions t() and c() and the transformation G(). There is one more caution to make here. We have not separated "x_" into variable parts and constant parts. If we always invoke a fractalization with a constant, ie f(X,Y,3.17), we ignore the constant in calculating the degree of the function or the fractalization. f(X,Y,3.17) is a second degree fractalization. The value 3.17 was not taken from a coordinate of the plane. It is a constant value at every point we evaluate at. It is passed as a variable be cause we wish to change its value as we recurse. We could also obtain this effect by adding a new function to our complete definition of a fractalization but currently we think this is simpler.
�
Lets do some of common fractalizations using this technique of describing the function f():
In general arithmetic symbols used follow the programming language C conventions. +, -, *, /, ^, >, <, >=, <= Are all defined the same way they are in C or Basic. ==, &&, || are the boolean functions for equals, and, or. They are taken form C. sin() and cos() are trig function. The two functions re() and im() extract the real and the imaginary parts of a complex variable. mod is the binary modulo operator, 3 mod 2 = 1. The function int() extracts the integer portion of a number. int(3.141) = 3. The operator rmod extracts the real modulus remainder of division. rmod is defined using the above defined operators as X rmod Y=X/Y - int(X/Y)*Y. An example is 3.141 rmod 2 = 1.141.
(1.) t(X,Y) = (int(X) mod 2) + (int(Y) mod 2) < 1Sierpinski Gasket Figure(2.) c(Z) = Z
(3.) m1(X,Y,Z) = X*2 m2(X,Y,Z) = Y*2 m3(X,Y,Z) = Z+1
(evaluate on XMIN=1, XMAX=2, YMIN=1, YMAX=2)
The template t(X,Y) determines if the point (X,Y) is in the lower left of a unit square.
(1.) t(X,Y) = sin(X)*sin(Y)<.3City.pcf Figure(2.) c(X,Y) = sin(X)*sin(Y)
(3.) m1(X,Y,Z) = X*Z m2(X,Y,Z) = Y*Z m3(X,Y,Z) = Z*1.007
In the next fractalization example, Z and Cons are complex variables! Z is taken from X and Y in the complex plane. X is the real part of Z, Y is the imaginary part of Z. Cons is a constant. re(Z) is the real part of Z, im(Z) is the imaginary part.
The formula x^2 + y^2 > 4 defines a template for a circle. Hence the statement, the Mandelbrot set is a fractalization of a circle. The formula re(Z)^2 + im(Z)^2 > 4 in the definition of t() above is a template for a circle. The part of the formula "|| Count>256" is included in order to guarantee the proceedure terminates!(1.) t(Z,Cons,Count) = re(Z)^2 + im(Z)^2 > 4 || Count>256
(2.) c(Z,Cons,Count) = Count
(3.) m1(Z,Cons,Count) = Z^2+Cons m2(Z,Cons,Count) = Cons m3(Z,Cons,Count) = Count-1
Mandelbrot Streo Pair (sort of done like above).
Converting the formulas from the above examples into computer programs presents varying degrees of difficulty. Seven Seas Software manufactures a program that makes these functions easy to calculate. MathVISION currently runs only on the Amiga but we anticipate that it will soon be available under OS/2 and later under other operating systems.
�
A fractalization plots the formula c(X,Y) in the true parts of the template. In the false parts of the template it changes the values of X and Y using the functions m#(). This can distort both the template and change the values passed to c(). It can shrink or expand the template, it can twist or otherwise distort it. The fractalization procedure recurses using these new distorted values. This allows one to build pictures which like the book that has its own picture on the cover, contains many pictures in pictures in pictures. Here are three different ways of looking at what fractalizing does.
First way: The fractalizing template determines where in the picture we are going to recurse and consequently where we scale the result. The scaling functions (m#() or the transform G()) in the equations determines by how much we scale the result.
Second way: The fractalizing equation is a shape which is itself scaled. It creates a template through which we can view other templates which are stacked up upon each other ad infinitum. Each scaling operation in distorts the template. We can look through the holes in the templates to successively more distant templates.
Third way: The template determines a 'trema' or an area of the plane we are viewing on the screen, which is what we cut away. The c() function is this cutting function. (What is colored is what we have eliminated from the set with the fractal dimension.) The scaling function scales, translates, rotates, and/or distorts this template which is then applied as a cutting function to the parts that are not cut away. This cutting and scaling are repeated recursively.
The second way to look at fractalizing above, as a series of templates, gives us a key for understanding why many of the fractalizations in this html document and elsewhere look three dimensional. They offer a view of a series of cutouts that have the appearance of, and are somewhat analogous to, the pictures in pop-up children books. The fractalization formula for City.pcf above shows this effect. The picture of the month, "Wierstrass Caverns" in the July issue of this magazine also shows this effect.
We can also generate fractals using perspective. The distance an object is away from the viewer determines its scale as projected on the retina. The Sierpinski gasket could be generated from cutouts all of the same size, but each one placed three times as far away from the viewer. At infinity, the cutout would have to be infinitely wide, but each piece would be identical to the one closest to the viewer.
The stereo pair fractalization of a pipe exploits this feature of a fractalization. The value of a counter that counts the number of iterations is used to provide a measure of how far away from the viewer each part of the picture is. The scaling transform G() is then based upon a perspective calculation.
Let the following universal values be defined. EyeX and EyeY and EyeD are the coordinates of the viewers eye. EyeD is the orthogonal distance from the viewers eye to the computer screen. EyeX and EyeY are the X,Y coordinates of the viewers eye. In order to do a 3-D sterio pair
We assume you have calculated EyeX, EyeY and EyeD before you invoke the function. In addition, we need a constant value Zinc that represents the distance between any two templates in our fractalization.
We then have the following constants.
We invoke this function with f(X,Y,EyeD,0)
Stereo of a pipe(1.) t(X,Y,Z,Count) = X^2 + Y^2 > 1 || Count>256
(2.) c(Count) = Count
(3.) m1(X,Y,Z) = EyeX+(X-EyeX)*Z/EyeD m2(X,Y,Z) = EyeY+(Y-EyeY)*Z/EyeD m3(X,Y,Z) = Z+Zinc m4(Count) = Count+1
We need to invoke this function twice with different values for EyeX in order to produce a right eye view and a left eye view.
In the next example, the Mandelbrot stereo pair, the perspective distortion already is a part of the picture (ie) the picture appears to be smaller and farther away in parts, consequently we only need to calculate an offset based on our level of recursion. This is easily done.
In this fractalization we do not use the complex variable Z but pass X and Y explicitly!
Let the following universal values be defined. EyeX and EyeY and EyeD are the coordinates of the viewers eye. EyeD is the orthogonal distance from the viewers eye to the computer screen. EyeX and EyeY are the X,Y coordinates of the viewers eye. In order to do a 3-D sterio pair EyeX is offset from the center of the screen first to the left, and then to the right. We do not use the variable EyeX and EyeY, but a displacement from the center of the screen OffX = ((Right_EyeX) - (Left_EyeX))/2. We assume you have calculate EyeD and OffX before you invoke the function. In addition, we need a constant value Zinc that represents the distance between the first two templates in our fractalization.
We also assume assume that the constants needed to calculate the Mandelbrot set are universal and were calculated before entering the function.
We then have the following constants.
(1.) t(X,Y,Count) = X^2 + Y^2 > 4 || Count>256
(2.) c(Count) = Count
(3.) m1(X,Y,Z) = X^2-Y^2+ConsX+Z /*REM This is for Left Eye m2(X,Y,Z) = 2*X*Y+ConsY m3(X,Y,Z,Count) = OffX - EyeD*OffX/(EyeD+Log(Count+1)*Zinc) m4(Count) = Count+1
Replace m1 with m1(X,Y,Z) = X^2-Y^2+ConsX-Z for right eye. The only difference is the sign of Z
�
It should be pointed out here that none of these recursive formulas are guaranteed to terminate given any two values of X and Y. In fact by putting a number in the variable Count in the pseudo code above for the Mandelbrot set, we guarantee that what we are looking at is only an estimation of what the Mandelbrot set looks like and not the Mandelbrot set itself. By definition, all the points actually within the Mandelbrot set would cause our formula to recurse for ever. Formulas for fractalizing are not necessarily guaranteed to have defined values every where. It is very possible that your program will make an attempt to divide by zero or find the square root of a negative number or overflow in some other manner. In our commercial product MathVISION, this is of course transparent, and the program will continue to evaluate, but when writing a program in any other computer language you will have to handle any divide by zeros, other math exceptions and arithmetic overflows and stack overflow explicitly.
�
We have given three different kinds of fractalizations in the three different formulas presented above. In the first, the Sierpinski carpet, we have a fractal whose fractal dimension is easy to calculate. The scaling operation scales the template by 1/2. This number 1/2 is the ratio r, defined in many books on fractals (page 37, Fractal Geometry of Nature. page 29, The Science of Fractal Images), it is also easy to calculate the values for N and D as defined in these references. How to do this and what it means is covered in more detail in part II of this paper.
In city.pcf, the scaling is not by a constant amount. The amount changes in each iteration. r1=(1/1.007),r2=(1/1.007)^2...rn=(1/1.007)^n . rn is the scaling factor at the nth iteration. From this we could calculate the rate of change of D. We do this in part II of this paper.
In the Mandelbrot set, we have a difficulty not presented in the two previous problems. Z*Z+Cons doesn't have a fixed scaling amount. Furthermore the rate of change of D may be difficult to calculate.
More information on fractalization is contained in the next part of this paper. There is a prerequisite for this, as it is moderately technical, you should have some understanding of the fractal similarity dimension D as defined in the Science of Fractal Images by Richard Voss on page 29 or by Benoit Mandelbrot in his The Fractal Geometry Of Nature on page 37. You should understand the formula N*r raised to the D power equals a constant or D=log(N)/log(1/r).
�
This essay is intended to be read in HTML. If any readers have any ideas on how to make this stuff more readable please let me know!
From Fractalizing part I we have:
the fractilazation f(x_) is defined on an n-vector x_ by a set of three functions:
IF t(x_) THEN
RETURN( c(x_) )
ELSE
RETURN( f(G(x_)) )
It may occasionally be useful to break the x_ in f(x_) into two parts, so that f(x_) becomes f(v_,c_) where v_ is a vector of variables and the number of elements of v_ determines the degree of the fractalization and the dimension of the space over which the fractalization is performed. c_ is the vector of constants and is the same for all invocations of f(v_,c_). x_ is the vector defined by combining the elements of both v_ and c_. This helps to clarify equations such as Julia curves defined by the Mandelbrot set where both a counter and a constant are required. The initial value of the constant appears in the vector c_ as do the real and imaginary parts of the constant.
The statements about fractalization made herein assume there are no arbitrary terminating procedures, such as are necessary to insure that implementation of fractals like the Mandelbrot set terminate for all values. When we talk about size, or area, we will be referring to Euclidean measurements.
�
In the definition of the Sierpinski gasket in part I we cheated, by including limit points on the edges of the squares we cut away recursively. We have rewritten the fractalization for the Sierpinski gasket below. In the first version of the Seirpinski gasket, The algorithm was guaranteed to terminate after a finite number of iterations (albeit arbitrarily large). In the rewritten version presented below, at some points (limit points on a unit square), the algorithm will never terminate. These limit points are the object which has a fractal dimension. In practice, when calculating our "Fractilizing dimension" it makes little difference which version you use, and practical programs must limit the depth of recursion for both forms of the algorithm. We have set c(X,Y) to equal the constant 1. All points at which the procedure would not terminate are assumed to be zero. This is the part of the object in which has a fractal dimension, in this case the Sierpinski gasket.
v_ = (X,Y)f(v_) is defined by:
A-(1.) t(v_)= t(X,Y) = (X rmod 2)<1 && (Y rmod 2)<1A-(2.) c(v_)= c(X,Y) = 1
A-(3.) G(v_)= G(X,Y) = m1(X,Y),m2(X,Y) where m1(X,Y) = X*2 m2(X,Y) = Y*2
We have set c(v_) to equal one to indicate that points that are set to zero by c() are not in the Sierpinski gasket. In practice this would produce a screen of a solid color. (Except if by some chance a point on the gasket was actually hit and the stack overflowed.) The fractal dimension D is a measure applied to the set of points remaining as the number of iterations approaches infinity. We can calculate the fractal dimension for objects that are clearly fractals, like the Sierpinski Gasket above, but also for some other fractalizations. We will also look at some objects for which the fractal dimension D is difficult to define. We will call our fractal dimension for fractalizations D' to distinguish it from the Similarity dimension D. D is equal to D' for all objects that we have considered that have both dimensions but we have not proved this rigorously. D' is a scaling dimension like D.
The transform implemented by A-(3.) in the Sierpinski Gasket above, is a scaling transform. A-(3.) sets r equal to 1/2 with the values X*2 and Y*2. This r is the same r as in the formula, D = log(N) / log(1/r) in reference books on fractals. Without proof at this point we will say that N is equal to 3, and D= log(3)/log(2) for the above gasket.
�
m1() and m2() can be implemented in a single step by operating on the 2-vector of v_ = (X,Y) with a 2 X 2 matrix M and possibly a vector addition. G(v_) = M*v_ + c_ If the matrix is non-singular it will be an affine transformation. If the matrix M is orthogonal then the operation will be a scaling operation. (It may also rotate and offset the values, this is known in geometry as a rigid transformation). If the transform is not realizable with a matrix multiplication by a constant matrix, and vector addition by a constant vector then the operation may still be a scaling operation, but considerably more difficult to analyze. If a connected set of points P has a volume or area defined for it denoted as A(P) and it has an image under the transformation G(P), then G() is a scaling operation if r = A(G(P))/A(P) is constant for all possible P. This ratio is the scaling ratio r. In order to calculate a constant for D, in a fractalization this ratio must be the same during every application of G(). P must be chosen from the space defined by the variable vector v_ in f(v_,c_) above. In other words, City.pcf fails this test because the scaling ratio r changes at each iteration. It is possible to study fractalizations in which the scaling ratio approaches a limit or behaves periodically.
In practice we can define our fractalization upon any set we like but in DMA it is nearly always defined upon the real plane. G() must be defined over some set of points and all possible P's must be chosen from this set. Granted this is not a rigorous definition. I have not dealt with sets that are not connected, nor have I defined connectedness, on the other hand it will be a sufficient enough definition for this short and informal essay. In the first part of this paper we gave four different fractalizations, only two of these were scaling under our definition. We can only calculate the fractal (similarity) dimension if G() is scaling.
�
Lets look at the template equation, A-(1.) above in the Sierpinski Gasket to try to determine its role in the fractalizing procedure. We wish to determine N which is necessary to calculate D. To do this we should observe that the template divides the plane (or a portion of the plane into two regions). In the case of the Sierpinski gasket above it is fairly easy to see that in a unit square upon which we build the gasket, the lower left hand corner of the template is 1/4 the total area. Furthermore the remaining area is 3/4ths of the total area. The scaling function scales the object by 1/2 which is a scaling by 1/(2^2) = 1/4 in euclidean 2 space. In other words, we scale the coordinates by a factor of 2, but the area changes by a factor of 4. This means we can pack 3 scaled versions of the template into the 3/4ths of the space which has not been cut away.
We will now define D for a fractalization. We will call this D' because it will correspond to D for many objects generated with other techniques (such as the Sierpinski gasket), but it will also be defined for some objects that we would not normally wish to call fractals. This is true because we are going to make no attempt in our definition to insure that the scaled versions of the template actually are able to fit in some meaningful manner into the space allocated to them, or in other words, we make no attempt when creating a stack of cutouts, to insure that the cutouts that are further away from us are visable throught the holes in the cutouts that are up close. It may be possible to doctor the value of D' by choosing areas that are inappropriate to evaluate it over. It is possible to build such a fractalization in which none of the scaled parts are visable through the first template. If implemented, the procedure to generate the fractal would terminate after the second iteration. On the other hand, G() would be scaling and the fractalization dimension D' would be calculatable. It is mentioned here because one should be careful about how they relate D' to D. In fact in the Sierpinski gasket, the scaling function doesn't need to translate the scaled version of the template in order to get it into the right position for the next iteration. We will discuss this problem a little more later in this essay.
The function t(), the template, divides the Euclidean space over which we wish to look at the fractilization (possibly the infinite plane,) into two parts. These are the parts where t() evaluates to 1 and where t() evaluates to 0. 1 corresponds to true, 0 corresponds to false. The set of points where t() evaluates to true can be denoted as True(Q) and the set of points where t() evaluates to false can be denoted as False(Q). To make this accurate Q should be chosen carefully. Q may be chosen as all of the euclidean plane. In the Sierpinski gasket above Q was chosen as the unit 2-dimensional square. If a template t() is periodic over all of space it may be appropriate to choose Q as the area covered by one period of t(). We must also insure that the template t() has the property that True(Q) and False(Q) can be assigned an area or volume. This property corresponds to the ability to integrate over True(Q) and False(Q). In the equations we have discussed, this is fairly easy to do. Let the area covered by True(Q) and the area covered by False(Q) be denoted as A(True(Q)) and A(False(Q)). A(Q) = A(True(Q))+A(False(Q)). The units of A() are units such as like inches squared in 2-space or inches cubed in 3-space. We can now define N'.
Where r is defined as above:
N' = A(False(Q)) / (A(Q) * r^E) D' = log(N')/log(1/r)
That is, N' is the area not sent to be cut away by the function c(), (3/4ths of the unit square in Sierpinski Gasket) divided by the total area times the scaling ratio raised to the Euclidean dimension. (1 * (1/2)^2) in Sierpinski gasket above.) The denominator is the area of a scaled version of the complete template. The numerator is the area of space available to pack little versions of the template into. The scaling function in the Sierpinski gasket scales the object by 1/2 which is a scaling by 1/(2^2) = 1/4 in euclidean 2 space. Sometimes it is useful to take A(False(Q)) / A(Q) and treat it as a constant multiplied times 1/r^E.
Note that the fractal dimension is only defined over Q.
�
Lets remember the following caveats.
�
For the Sierpinski gasket:
r = 1/2
E = 2
A(Q) = 1
A(False(Q)) = 3/4
N' = (3/4) / (1 * (1/2)^2 ) = 3
D' = log(8)/log(3)
Which is identical to D, derived through other techniques.
In order to show how different D' can be compared to D, define a new fractalization called circles.pcf
Define circles.pcf as f(X,Y,Z) which we invoke as f(X,Y,1).
C-(1.) t(X,Y) = ((X^2 + Y^2) mod 7) > 4Circles FigureC-(2.) c(Z) = Z
c-(3.) m1(X,Y,Z) = X*1.2-sin(Z) m2(X,Y,Z) = Y*1.3+cos(Z) m3(X,Y,Z) = Z+1
The value of Z is incremented by one during each recursion. In other words it counts the depth we are at in the recursion. Z is used to color the plot and in cos(Z) and sin(Z) to translate the plot. G() is a scaling function according to our definition. We require that A(G(P))/A(P) be constant for sets of connected P in the Euclidean plane. (Which we will take as the area over which we are interested in the function. Q is all of the plane.) X and Y are the coordinates we take from Euclidian 2-space. The terms sin(Z) and cos(Z) in m1() and m2() translate points operated on by G(). (We need only consider G() with Z constant.) These trigonometric terms have no effect upon the area of the image of P in G(P). The values 1.2 and 1.3 are scaling values and do have an effect. They scale the area of A(G(P))/A(P) by (1/1.2)*(1/1.3) = 1/1.56. (for instance, the preimage of a rectangle P operated on by G() is a rectangle with the sides 1.2 and 1.3 times larger) The square root of this value is ~= .8 We calculate the square root of (1/1.56) because we are in 2-space. This is our value for r' when calculating D'. N' is a little bit harder to calculate. We have to evaluate the ratio of the non cut away area to the whole area as the value of x^2+y^2 gets big. We do not include this calculation here but do state its approximate value below. For the whole of the infinite plane Q,
A(False(Q)) / A(Q) approaches .7143
r' = .8
N' = A(False(Q)) / (A(Q) * r^E)
N' ~= .7143 * 1/(r^E) ~= 1.116
D' ~= .4918
There are many problems with this value of D' although we have calculated it carefully.
To illustrate some of the ways D' is different from D consider the following.
City.pcf f(X,Y,1) is defined by:
D-(1.) t(X,Y) = sin(X)*sin(Y)<.3City.pcf FigureD-(2.) c(X,Y) = sin(X)*sin(Y)
D-(3.) m1(X,Y,Z) = X*Z m2(X,Y,Z) = Y*Z m3(X,Y,Z) = Z*1.007
In this fractalization the value of r is constantly changing. The scaling amount is set by Z. Z is multiplied by 1.007 at each iteration. The formula for r after n iterations through D-(3.) is 1/1.007^n. Because of this constantly changing r value, it is impossible to calculate a single D' for the picture. But by plugging the values we know for r into the formula we can learn something about how this kind of equation behaves. Lets let 1.007 be represented by a variable k1. k1 is a constant value and we will explore the different ways the formula behaves with different values of k1 . Lets let A(False(Q)) / A(Q) be represented by another variable k2. Given the two equations:
N' = A(False(Q)) / (A(Q) * r^E) D' = log(N')/log(1/r)
We can rewrite D' as log(k2 * 1/(k2^n)^E)/log(1/k2^n) This simplifies to
D' = (log(k2)-E*log(k1^n))/-log(k1^n)
= E - log(k2)/log(k1^n)
= E - (1/n)*log(k2)/log(k1)
If k1>1 then D' approaches E as n goes to infinity. If k2 < 1 then D' approaches negative infinity. If k1=1 then D' is indeterminate. Notice that in this case D' has a derivative with respect to n which may be calculated.
�
All of this leads to questions and observations.