# Mobius Functions # Mobius Functions Support

The Fractal Science Kit fractal generator Mobius functions are associated with the Mobius object:

Object Mobius { A : B : C : D }

The fields A, B, C, and D, are complex numbers that define a Mobius Transformation.

The following example illustrates how you would define a Mobius object using the object's constructor:

Mobius m = Mobius(A, B, C, D)

This example assigns a Mobius transformation to the variable m. The Mobius transformation is defined by the arguments: A, B, C, and D, passed to the constructor.

Mobius Mobius.Identity()
Mobius Mobius.Inverse(Mobius m)
Complex Mobius.Determinate(Mobius m)
Complex Mobius.Trace(Mobius m)
void Mobius.Normalize(byref Mobius m)

Mobius.Identity returns the identity Mobius transformation. Mobius.Inverse returns the inverse of the transformation. Mobius.Determinate returns the determinate of the Mobius transformation. Mobius.Trace returns the trace of the Mobius transformation. Mobius.Trace requires the Mobius transformation m to be normalized. Mobius.Normalize normalizes the given Mobius transformation.

Mobius Mobius.Multiply(Mobius m1, Mobius m2)
Mobius Mobius.Multiply3(Mobius m1, Mobius m2, Mobius m3)
Mobius Mobius.Multiply4(Mobius m1, Mobius m2, Mobius m3, Mobius m4)
Mobius Mobius.MultiplyArray(Mobius m[], count)
void Mobius.ArrayMultiply(Mobius m1[], Mobius m2[], count, Mobius result[])
void Mobius.MultiplyNxM(Mobius m1[], Mobius m2[], Mobius result[])
Mobius Mobius.Power(Mobius m, power)
void Mobius.GeneratePowers(Mobius m, count, Mobius pow[])

Mobius.Multiply returns the product of Mobius transformations m1 and m2. Mobius.Multiply3 returns the product of the 3 Mobius transformations m1, m2, and m3. Mobius.Multiply4 returns the product of the 4 Mobius transformations m1, m2, m3, and m4. Mobius.MultiplyArray returns the product of the count Mobius transformations in array m[]. Mobius.ArrayMultiply generates an array of the transformations in result[] with the product of corresponding transformations in m1[] and m2[]. All 3 arrays should be dimensioned count. Mobius.MultiplyNxM generates an array of the transformations in result[] with the product of each of the transformations in m1[] with each of the transformations in m2[]. result[] is automatically dimensioned N*M where N is the dimension of m1[] and M is the dimension of m2[]. Mobius.Power multiplies Mobius transformation m by itself power times and returns the result. Mobius.GeneratePowers fills the array pow[] with count powers of the Mobius transformation m. Array pow[] should be dimensioned count.

void Mobius.Translate(byref Mobius m, shift)
void Mobius.Rotate(byref Mobius m, angle)
void Mobius.RotateAboutPoint(byref Mobius m, point, angle)
void Mobius.Scale(byref Mobius m, factor)
void Mobius.ScaleAboutPoint(byref Mobius m, point, factor)

Each of these methods modifies the Mobius transformation m by injecting the named transformation into m. For example, Mobius.Translate injects a translation by shift into m. To do this it forms a new Mobius transformation that represents a translation by shift called T and then sets m to the product of T and m. shift is a complex number and shift.x and shift.y are the x and y translation components. Mobius.Rotate injects a rotation by angle radians into m. Mobius.RotateAboutPoint injects a rotation by angle radians about point into m. Mobius.Scale injects a magnification by factor (float) about the origin into m. Mobius.ScaleAboutPoint injects a magnification by factor about point into m.

'
' Inject complex inversion into m (z -> 1/z).
' This is not the same as inversion (z -> 1/Conj(z))
' which cannot be represented by a Mobius transformation.
'
void Mobius.ApplyInversion(byref Mobius m)
'
' Inject complex inversion in a circle with the given
' center and radius into m. This is not the same
' as inversion which cannot be represented by a
' Mobius transformation.
'
void Mobius.Invert(byref Mobius m, center, radius)

Mobius.ApplyInversion injects a complex inversion into m. Mobius.Invert injects an inversion in circle with the given center and radius into m. Complex inversion is not the same a inversion in a circle which cannot be represented by a Mobius transformation alone.

Complex Mobius.TransformPoint(Mobius m, z)
Complex Mobius.InverseTransformPoint(Mobius m, z)
Circle Mobius.TransformCircle(Mobius m, Circle c)

Mobius.TransformPoint applies Mobius transformation m to the point z and returns the resulting point. Mobius.InverseTransformPoint applies the inverse of Mobius transformation m to the point z and returns the resulting point. Mobius.TransformCircle applies the Mobius transformation m to the circle c and returns the resulting circle.

Mobius Mobius.Map3(z1, z2, z3)
Mobius Mobius.Map3to3(p1, p2, p3, q1, q2, q3)
Mobius Mobius.MapTriangletoTriangle(Triangle t1, Triangle t2)
Mobius Mobius.MapCircleToCircle(Circle c1, Circle c2)

Mobius.Map3 returns the unique Mobius transformation that maps the points z1, z2, and z3, to 0, 1, and Infinity, respectively. Mobius.Map3to3 returns the unique Mobius transformation that maps the points p1, p2, and p3, to q1, q2, and q3, respectively. Mobius.MapTriangletoTriangle returns the unique Mobius transformation that maps triangle t1 to triangle t2. Mobius.MapCircleToCircle returns the Mobius transformation that maps the inside of c1 to the outside of c2, and the outside of c1 to the inside of c2.

Mobius Mobius.Elliptic(p, q, angle)
Mobius Mobius.Hyperbolic(p, q, scale)
Mobius Mobius.Loxodromic(p, q, angle, scale)
Mobius Mobius.Parabolic(p, offset)

These functions create each of the 4 different types of Mobius transformation.

Mobius.Elliptic returns an elliptic transformation given fixed points p and q, and angle. angle is the radian angle of rotation about the fixed points. If angle is 0, the result is the identity transformation.

Mobius.Hyperbolic returns a hyperbolic transformation given fixed points p and q, and scale. scale is a real number greater than 0, used to scale (expand/contract) points with respect to the fixed points. If the scale is 1, the result is the identity transformation. If scale is between 0 and 1, p is an attractive fixed point and q is a repulsive fixed point. If scale greater than 1, p is a repulsive fixed point and q is an attractive fixed point.

Mobius.Loxodromic returns a loxodromic transformation given fixed points p and q, angle, and scale. angle is the radian angle of rotation about the fixed points. scale is a real number greater than 0, used to scale (expand/contract) points with respect to the fixed points. If angle is 0, this becomes a hyperbolic transformation. If the scale is 1, this becomes an elliptic transformation. If angle is 0 and scale is 1, the result is the identity transformation.

Mobius.Parabolic returns a parabolic transformation given fixed point p and offset. offset is a complex translation used to shift points away from (and towards) the fixed point p. If offset is 0, the result is the identity transformation.

Mobius Mobius.EllipticDiskAutomorphism(Center, Radius, Angle, Magnitude, Argument, Theta)
Mobius Mobius.HyperbolicDiskAutomorphism(Center, Radius, Angle, Argument, Scale)
Mobius Mobius.ParabolicDiskAutomorphism(Center, Radius, Angle, Argument, Offset)

These functions return a disk automorphism as an elliptic, hyperbolic, or parabolic transformation respectively. A disk automorphism maps the given disk onto itself; i.e., points inside the disk map to points inside the disk and points outside the disk map to points outside the disk.

Center, Angle, and Radius define the disk and the remaining arguments control the resulting transformation.

For the elliptic transformation, Magnitude and Argument define the magnitude and argument of a fixed point in the unit circle and Theta defines an angle of rotation around the fixed point.

For the hyperbolic transformation, Argument defines the argument of a fixed point on the unit disk and Scale defines an expansion/contraction factor about the fixed point. Scale should be greater than 0.

For the parabolic transformation, Argument defines the argument of a fixed point on the unit disk and Offset defines a translation offset away from (or towards) the fixed point.

Mobius Mobius.DiskAutomorphism(Center, Radius, Angle, Theta, P)

Mobius.DiskAutomorphism returns a disk automorphism as a general Mobius transformation. A disk automorphism maps the given disk onto itself; i.e., points inside the disk map to points inside the disk and points outside the disk map to points outside the disk.

Center, Angle, and Radius define the disk and the remaining arguments control the resulting transformation.

Theta is the rotation applied to the disk and P is the point in the unit circle mapped to the disk origin.

Mobius Mobius.HalfPlaneToDisk(Center, Radius, Angle, Theta, P, Inverse)

Mobius.HalfPlaneToDisk maps the upper half-plane onto a disk.

Center, Angle, and Radius define the disk and the remaining arguments control the resulting transformation.

Theta is the rotation applied to the disk and P is the point in the unit circle mapped to the disk origin. Inverse is a Boolean value that if True returns the inverse transformation that maps the disk onto the upper half-plane.

Mobius Mobius.UnitCircleGroup(angle, z0)

Mobius.UnitCircleGroup returns a Mobius transformation defined as:

f(z) = Cis(angle) * (z - z0)/(1 - Conj(z0)*z)

Mobius.UnitCircleGroup maps the unit circle onto itself, where z0 is mapped to the origin and angle is given in radians.

void Mobius.FixedPoints(Mobius m, byref source, byref sink)
Complex Mobius.Source(Mobius m)
Complex Mobius.Sink(Mobius m)

Mobius.FixedPoints computes the fixed points of the Mobius transformation m. These are returned in source and sink. Mobius.Source returns the fixed point source of Mobius transformation m. Mobius.Sink returns the fixed point sink of Mobius transformation m. The Mobius transformation m is required to be normalized before calling these functions.

'
' Grandma's Recipe given in Box 21 on page 229 of the book:
'   "Indra's Pearls, The Vision of Felix Klein"
' by David Mumford, Caroline Series, David Wright.
' http://klein.math.okstate.edu/IndrasPearls/
'
void Mobius.GrandmaRecipe(traceA, traceB, root, byref Mobius a0, byref Mobius b0)
'
' Jergensen's Recipe given in Box 22 on page 256 of the book:
'   "Indra's Pearls, The Vision of Felix Klein"
' by David Mumford, Caroline Series, David Wright.
' http://klein.math.okstate.edu/IndrasPearls/
'
void Mobius.JergensenRecipe(traceA, traceB, root, byref Mobius a0, byref Mobius b0)
'
' Riley's Recipe given on page 258 of the book:
'   "Indra's Pearls, The Vision of Felix Klein"
' by David Mumford, Caroline Series, David Wright.
' http://klein.math.okstate.edu/IndrasPearls/
'
void Mobius.RileyRecipe(c, byref Mobius a0, byref Mobius b0)
'
' Maskit's Recipe given on page 259 of the book:
'   "Indra's Pearls, The Vision of Felix Klein"
' by David Mumford, Caroline Series, David Wright.
' http://klein.math.okstate.edu/IndrasPearls/
'
void Mobius.MaskitRecipe(mu, byref Mobius a0, byref Mobius b0)
'
' Grandma's 4-alarm 2-generator groups Recipe
' given in Box 23 on page 261 of the book:
'   "Indra's Pearls, The Vision of Felix Klein"
' by David Mumford, Caroline Series, David Wright.
' http://klein.math.okstate.edu/IndrasPearls/
'
void Mobius.Grandma2GeneratorRecipe(traceA, traceB, traceAB, byref Mobius a0, byref Mobius b0)

These are several recipes given in the book by David Mumford, Caroline Series, and David Wright. These are used in a few of the built-in Orbit Traps and Orbital Equations. See the book for details.

'
' This function constructs the p/q word as described on
' page 276 of the book:
'   "Indra's Pearls, The Vision of Felix Klein"
' by David Mumford, Caroline Series, David Wright.
' http://klein.math.okstate.edu/IndrasPearls/
'
' p and q should be integers >= 0. Both may not be 0.
'
' The word[] array is filled with transformations
' (a|B) such that Mobius.MultiplyArray(word[]) is
' the p/q word.
'
void Mobius.PQWordArray(p, q, Mobius a, Mobius B, Mobius word[])
'
' This function constructs the p/q word as described on
' page 276 of the book:
'   "Indra's Pearls, The Vision of Felix Klein"
' by David Mumford, Caroline Series, David Wright.
' http://klein.math.okstate.edu/IndrasPearls/
'
' p and q should be integers >= 0. Both may not be 0.
'
Mobius Mobius.PQWord(p, q, Mobius a, Mobius B)

These methods are based on algorithms given in the book by David Mumford, Caroline Series, and David Wright. These are used in a few of the built-in Orbit Traps and Orbital Equations. See the book for details.

void Mobius.GenerateSymmetryTransformationPoints( \
SymmetryTransformationInfo symmetryArray[], \
Mobius s[], \
count, \
z \
)

Mobius.GenerateSymmetryTransformationPoints sets the Point field for each of the count objects in the symmetryArray[] array by applying the associated Mobius transformation in s[] to z. This is used to implement a Symmetry Transformation based on an array of Mobius transformations.

#define TransformationShiftIndexMapTypes

enum TransformationShiftIndexMapTypes {
Shift, "Transformation Shift Index"
Array, "Transformation Array Index"
Both, "Both"
}
#end

void Mobius.ApplyTransformationShift( \
SymmetryTransformationInfo symmetryArray[], \
Mobius shiftArray[], \
shiftCount, \
indexMap, \
z \
)

Mobius.ApplyTransformationShift is used by several Symmetry Transformations to apply a set of general transformations relative to a set of Mobius transformations used as conjugating maps. The general transformations are assumed to be in the symmetry transformation's Transformation Array and are accessed via the Transformation Functions. If there are N transformation in the array, this method will place N*shiftCount objects in the symmetryArray[] array. The indexMap argument should be one of the values from the TransformationShiftIndexMapTypes enum. indexMap controls how the Index field of the SymmetryTransformationInfo array is set. See the implementation in the built-in macros for details.