reb Class Mobius

Object reb:Mobius

class
Object:Mobius

Creates Mobius transformations in a matrix format.

T(z) = (az+b)/(cz+d)

T is a Mobius Transformation were z, a, b, c and d are complex numbers. T is typically represented in normalized matrix form:

T = | a b |
| c d |

T is normalized if the determinant of ad-bc = 1

A Mobius Transformation can be viewed as a composition of translation, scaling and inversion.

The Trace of T is TrT = a+ d

Ultra Fractal Source
class Mobius {
; Creates Mobius transformations in a matrix format. <br>
; <p>
; T(z) = (az+b)/(cz+d) <br>
; <p>
; T is a Mobius Transformation were z, a, b, c and d are complex
; numbers. T is typically represented in normalized matrix form:
; <p>
;       T =   | a  b |  <br>
;             | c  d |  <br>
; <p>
; T is normalized if the determinant of ad-bc = 1 <br>
; <p>
; A Mobius Transformation can be viewed as a composition of translation,
; scaling and inversion.
; <p>
; The Trace of T is TrT = a+ d

public:

; Mobius constructor for T(a, b, c, d)
; @param a = a value
; @param b = b value
; @param c = c value
; @param d = d value
func Mobius(complex a, complex b, complex c, complex d)
m_a = a
m_b = b
m_c = c
m_d = d
m_TrT = m_a + m_d
endfunc

; Circle to Mobius
func CircToMob(Mobius T, Sphere s)
; Lines and Circles can be represented as Mobius Transforms. Lines and
; Circles are equivalent in Riemann space. For convenience circles are
; represented as sphere objects
complex unit = 0
complex im = (0,1)
; matrix of line
m_a = im*unit
m_b = im*(conj(unit)*s.fcen-unit*conj(s.fcen))
m_c = 0
m_d = im*conj(unit)
else
; matrix of circle
endif
endfunc

; Mobius to Circle
func MobToCirc(int level, int rgen, Sphere s)
; A Mobius Transform can be represented as a Line or Circle. In
; Reimann space a line is a circle with a negative radius. The
; 'level' and 'rgen' arguments are for the Kleinian inversion algorithms
float LINEFUZZ  = 1e-5
if real(m_c) < LINEFUZZ && real(m_c) > - LINEFUZZ
; matrix to line
s.fcen = -m_b*m_a/2
else
; matrix to circle
s.fcen = m_a/m_c
endif
s.flevel = level
s.fgen = rgen
endfunc

; Normalize Mobius
func Normalize(Mobius T)
complex det = T.m_a*T.m_d-T.m_b*T.m_c
det = 1/sqrt(det)
T.m_a = m_a*det
T.m_b = m_b*det
T.m_c = m_c*det
T.m_d = m_d*det
endfunc

; Invert Mobius
func Invert(Mobius T)
complex det = m_a*m_d-m_b*m_c
T.m_a = m_d
T.m_b = -m_b
T.m_c = -m_c
T.m_d = m_a
if real(det) <= 0
T.m_a = -conj(T.m_a)
T.m_b = -conj(T.m_b)
T.m_c = -conj(T.m_c)
T.m_d = -conj(T.m_d)
endif
endfunc

; Multiplication
func Mult(Mobius T1, Mobius T2)
; T2 = T * T1 This does not commute.
;
complex det = m_a*m_d-m_b*m_c
if real(det) <= 0
T2.m_a = m_a*conj(T1.m_a)+m_b*conj(T1.m_c)
T2.m_b = m_a*conj(T1.m_b)+m_b*conj(T1.m_d)
T2.m_c = m_c*conj(T1.m_a)+m_d*conj(T1.m_c)
T2.m_d = m_c*conj(T1.m_b)+m_d*conj(T1.m_d)
else
T2.m_a = m_a*T1.m_a+m_b*T1.m_c
T2.m_b = m_a*T1.m_b+m_b*T1.m_d
T2.m_c = m_c*T1.m_a+m_d*T1.m_c
T2.m_d = m_c*T1.m_b+m_d*T1.m_d
endif
endfunc

; Conjugate
func MConj(Mobius T1,Mobius T2)
; T2 = T * T1 * inverse(T)
Mobius igen = new Mobius(0,0,0,0)
; Inverse of T
this.Invert(igen)
Mobius prod1 = new Mobius(0,0,0,0)
this.Mult(T1,prod1)
prod1.Mult(igen,T2)
endfunc

; Mobius Trace
complex func Trace(Mobius T)
return T.m_a + T.m_d
endfunc

complex m_a
complex m_b
complex m_c
complex m_d
complex m_TrT

default:
title = "Mobius Methods"
int param v_mobius
caption = "Version (Mobius Methods)"
default = 101
hint = "This version parameter is used to detect when a change has been made to the formula that is incompatible with the previous version. When that happens, this field will reflect the old version number to alert you to the fact that an alternate rendering is being used."
visible = @v_mobius < 101
endparam
}

Constructor Summary
Mobius()

Mobius(complex a, complex b, complex c, complex d)
Mobius constructor for T(a, b, c, d)

Method Summary
void CircToMob(Mobius T, Sphere s)
Circle to Mobius
void Invert(Mobius T)
Invert Mobius
void MConj(Mobius T1, Mobius T2)
Conjugate
void MobToCirc(int level, int rgen, Sphere s)
Mobius to Circle
void Mult(Mobius T1, Mobius T2)
Multiplication
void Normalize(Mobius T)
Normalize Mobius
complex Trace(Mobius T)
Mobius Trace

Methods inherited from class Object

Constructor Detail

Mobius

public Mobius(complex a,
complex b,
complex c,
complex d)
Mobius constructor for T(a, b, c, d)

Parameters:
a - = a value
b - = b value
c - = c value
d - = d value

public Mobius()
Method Detail

CircToMob

public void CircToMob(Mobius T,
Sphere s)
Circle to Mobius

MobToCirc

public void MobToCirc(int level,
int rgen,
Sphere s)
Mobius to Circle

Normalize

public void Normalize(Mobius T)
Normalize Mobius

Invert

public void Invert(Mobius T)
Invert Mobius

Mult

public void Mult(Mobius T1,
Mobius T2)
Multiplication

MConj

public void MConj(Mobius T1,
Mobius T2)
Conjugate

Trace

public complex Trace(Mobius T)
Mobius Trace