## 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

### Mobius

`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