## mmf Class MMF_SwitchRecursion

```Object
common:Generic
common:Formula
common:ConvergentDivergentFormula
mmf:MMF_SwitchConvergentDivergentFormula
mmf:MMF_SwitchRecursion
```

`class MMF_SwitchConvergentDivergentFormula:MMF_SwitchRecursion`

This formula is an adaption of 'Switch Recursion' from mmfs.ufm which itself was based on the Lucas recursion formula found on Mathworld.

Note that for historical reasons this formula uses its own zold and bailout values instead of those defined in the base class doing so should not be taken as a model for other formulas.

Ultra Fractal Source
``` class MMF_SwitchRecursion(MMF_SwitchConvergentDivergentFormula) {
; This formula is an adaption of 'Switch Recursion' from mmfs.ufm
; which itself was based on the Lucas recursion formula found on Mathworld.<p>
; Note that for historical reasons this formula uses its own
; zold and bailout values instead of those defined in the base class
; doing so should not be taken as a model for other formulas.<br>
public:
import "common.ulb"

; @param pparent the parent, generally "this" for the parent, or zero
func MMF_SwitchRecursion(Generic pparent)
MMF_SwitchConvergentDivergentFormula.MMF_SwitchConvergentDivergentFormula(pparent)
fTransform0 = new @p_Transform0(this)
fTransform1 = new @p_Transform1(this)
fTransformPZ = new @p_TransformPZ(this)
fTransformP = new @p_TransformP(this)
fTransformQZ = new @p_TransformQZ(this)
fTransformQ = new @p_TransformQ(this)
fTransformX = new @p_TransformX(this)
fTransformD = new @p_TransformD(this)
endfunc

complex func Init(complex pz)
;    m_Iterations = 0 not used in this formula
m_BailedOut = false
fTransform0.Init(pz)
fTransform1.Init(pz)
fTransformPZ.Init(pz)
fTransformP.Init(pz)
fTransformQZ.Init(pz)
fTransformQ.Init(pz)
fTransformX.Init(pz)
fTransformD.Init(pz)
if fType
fConstant = pz
fZold = pz = fValue + fConstant
else
fZold = pz = fValue
endif
else
fZold = pz
endif
if @p_type=="Iterative"
m_p = m_p0 = fTransform0.Iterate(pz)
m_p1 = fTransform1.Iterate(pz)
m_recursecount = 2
endif
return pz
endfunc

complex func Iterate(complex pz)
;    m_Iterations = m_Iterations + 1 not used in this formula
if @p_type=="Normal"
complex p
complex p0 = fTransform0.Iterate(pz)
complex p1 = fTransform1.Iterate(pz)
int i = 2
repeat
p = ((fTransformPZ.Iterate(i)*pz + fTransformP.Iterate(i))*p1 \
+ (fTransformQZ.Iterate(i)*pz + fTransformQ.Iterate(i))*p0) \
/ fTransformD.Iterate(i)
p0 = p1
p1 = p
until (i=i+1)>@p_recurse
m_p = p1
else;if @p_type=="Iterative"
m_p = ((fTransformPZ.Iterate(m_recursecount)*pz \
+ fTransformP.Iterate(m_recursecount))*m_p1 \
+ (fTransformQZ.Iterate(m_recursecount)*pz \
+ fTransformQ.Iterate(m_recursecount))*m_p0) \
/ fTransformD.Iterate(m_recursecount)
m_p0 = m_p1
m_p1 = m_p
m_recursecount = m_recursecount + 1
endif
if @p_fractal=="Pn(z)+c"
m_p = fTransformX.Iterate(m_p) + fConstant
elseif @p_fractal=="c*Pn(z)"
m_p = fConstant*fTransformX.Iterate(m_p)
elseif @p_fractal=="Pn(z)+zold+c"
m_p = fTransformX.Iterate(m_p) + fZold + fConstant
elseif @p_fractal=="c*Pn(z)+zold"
m_p = fConstant*fTransformX.Iterate(m_p) + fZold
elseif @p_fractal=="zold*Pn(z)+c"
m_p = fZold*fTransformX.Iterate(m_p) + fConstant
else;if @p_fractal=="c*zold*Pn(z)"
m_p = fConstant*fZold*fTransformX.Iterate(m_p)
endif
fZold = pz
return m_p
endfunc

bool func IsBailedOut(complex pz)
if ((@p_BailType=="Divergent" || @p_BailType=="Both" \
|| @p_BailType=="Div.+Abs.Conv.") \
&& |pz|>=@p_Bailout) \
|| ((@p_BailType=="Convergent" || @p_BailType=="Both") \
&& |pz-fZold|<=@p_SmallBail) \
|| ((@p_BailType=="Absolute Convergence" \
|| @p_BailType=="Div.+Abs.Conv.") \
&& |pz-@p_root|<=@p_SmallBail )
m_BailedOut = true
endif
return m_BailedOut
endfunc

float func GetUpperBailout()
return @p_Bailout
endfunc

float func GetLowerBailout()
return @p_SmallBail
endfunc

complex func GetPrimaryExponent()
return @p_recurse
endfunc

private:
Transform fTransform0
Transform fTransform1
Transform fTransformPZ
Transform fTransformP
Transform fTransformQZ
Transform fTransformQ
Transform fTransformX
Transform fTransformD
complex fZold
complex m_p
complex m_p0
complex m_p1
int m_recursecount

default:
title = "Switch Recursion"
int param v_mmfswitchrecursion
caption = "Version (MMF Switch Recursion)"
enum = "1.0"
default = 0
hint = "This field is to absolutely ensure backward compatibility, \
the default will always be set to the latest version, but \
there may be some cases where an older effect that you like \
is lost in an update and you could still use it by selecting \
the older version number."
visible = false
endparam
float param p_upperbailout
visible = false
endparam
float param p_lowerbailout
visible = false
endparam
caption = "Offset z start"
default = false
hint = "When enabled the z start value (in Mandelbrot mode) is offset \
by the constant for the current position - normally '#pixel'."
visible = !@p_manual || @p_mandy
endparam
complex param p_power
visible = false
endparam
caption = "Information"
text = "This formula is an adaptation of 'Switch Recursion' from \
mmfs.ufm which itself was based on the Lucas recursion \
formula found on Mathworld. Tip: You'll often find that \
the best Mandelbrot start value (critical value) is \
non-zero when you change the recursion parameters. You \
can use the switch back from the Julia to the Mandelbrot \
to help find the critical value - it's usually when the \
Mandelbrot 'lake' is at its largest, if you stick to real \
values for the recursion parameters then the critical \
value should also be real. Note that it's often worth trying \
values such as -1, -0.5, 0.5 or 1 as the Mandelbrot start \
value. For those more mathematically inclined see the details \
of the 'Transpoly' formula in mmf.html for details of several \
classic polynomial functions that you can create using this \
formula by setting the recursion transforms and values \
appropriately."
caption = "Bailout Options"
text = "Depending on the transforms you choose your fractal could \
be either divergent or convergent. You need to choose the \
correct type to produce a result, a symptom of choosing the \
wrong type is an image in a single solid colour e.g. black. \
Sometimes fractals produce both types of 'vergence and for \
these you can choose 'Both'."
int param p_BailType
caption = "Bailout Type"
enum = "Divergent" "Convergent" "Both" "Absolute Convergence" \
"Div.+Abs.Conv."
default = 0
hint = "If you get an empty or nearly empty fractal try switching \
from 'Divergent' to 'Convergent' or vice-versa or choosing \
'Both'. Note that in some cases if your fractal is a \
Mandelbrot you may need to ensure that the zstart value \
is non-zero."
endparam
complex param p_root
caption = "Convergence Value"
default = (1,0)
hint = "This is the value for testing for convergence to. For the \
'Magnet' formulas the value should be (1,0), if you don't \
know the value to use it's best to stick to the plain \
'Convergent' 'Bailout Type'. It's always worth trying (0,0)."
visible = @p_BailType>2
endparam
float param p_Bailout
caption = "Divergent Bailout"
default = 128.0
hint = "In general larger values will require higher iterations."
visible = @p_BailType==0 || @p_BailType==2 || @p_BailType==4
endparam
float param p_SmallBail
caption = "Convergent Bailout"
default = 1e-5
hint = "In general smaller values will require higher iterations."
visible = @p_BailType>0
endparam
caption = "Fractal Method"
int param p_type
caption = "Recursion Type"
enum = "Normal" "Iterative"
default = 0
hint = "When you specify 'Normal' a set number of recursions are \
performed on each iteration, the number of recursions will \
control the degree (exponent) of the fractal (at least for \
divergent fractals). When you choose 'Iterative' the \
recurrence relation is performed as the iterations i.e. for \
divergent fractals the degree increases with the number of \
iterations."
endparam
int param p_recurse
caption = "Number of Recursions"
default = 6
min = 2
hint = "The number of recursions to perform on each iteration. The \
minimum is 2. Using the defaults a count of 2 will produce \
a degree 2 fractal, 3 will produce a degree 3 fractal and so \
on."
visible = @p_type==0
endparam
Transform param p_TransformX
caption = "Transform of Pn(z)"
default = NullTransform
hint = "Here you may specify a transform of the recurrence \
function Pn(z) before it is plugged into the 'Fractal \
Formula'."
endparam
int param p_fractal
caption = "Fractal Formula"
enum = "Pn(z)+c" "c*Pn(z)" "Pn(z)+zold+c" "c*Pn(z)+zold" \
"zold*Pn(z)+c" "c*zold*Pn(z)"
default = 0
hint = "Normally the recurrence relation you set using the \
transforms will produce a polynomial in z, Pn(z). \
Here you can choose how Pn(z) is used to produce a \
fractal."
endparam
caption = "Recursion Equations"
text = "Here you can set the equations used for the recurrence \
relation by choosing appropriate transforms. \
The recurrence relation works as follows: Two base \
equations are used, P0(z) and P1(z) and on each recursion \
Pn(z) is created as Pn(z) = ((Q(n)*z + R(n))*Pn-1(z) + \
(S(n)*z + T(n))*Pn-2(z))/D(n) where Q(n), R(n), S(n), T(n) \
and D(n) are functions of the recurrence level n. You \
specify P0 as 'Transform 0', P1 as 'Transform 1', Q as \
'Transform Q', R as 'Transform R', S as 'Transform S', T \
as 'Transform T' and D as 'Transform D'. The formula is \
really designed so you should use either the 'Constant Value', \
'Simple Scale' or 'Linear' transforms from mmf.ulb but \
interesting results may arise from almost any transform :)"
Transform param p_Transform0
caption = "Transform 0"
default = MMF_Scale
hint = "P0(z)"
endparam
Transform param p_Transform1
caption = "Transform 1"
default = MMF_Scale
hint = "P1(z)"
endparam
Transform param p_TransformPZ
caption = "Transform Q"
default = MMF_Constant
hint = "Q(n) in (Q(n)*z + R(n))*Pn-1(z) + (S(n)*z + T(n))*Pn-2(z)"
endparam
Transform param p_TransformP
caption = "Transform R"
default = MMF_Constant
hint = "R(n) in (Q(n)*z + R(n))*Pn-1(z) + (S(n)*z + T(n))*Pn-2(z)"
endparam
Transform param p_TransformQZ
caption = "Transform S"
default = MMF_Constant
hint = "S(n) in (Q(n)*z + R(n))*Pn-1(z) + (S(n)*z + T(n))*Pn-2(z)"
endparam
Transform param p_TransformQ
caption = "Transform T"
default = MMF_Constant
hint = "T(n) in (Q(n)*z + R(n))*Pn-1(z) + (S(n)*z + T(n))*Pn-2(z)"
endparam
Transform param p_TransformD
caption = "Transform D"
default = MMF_Constant
hint = "The polynomial is divided by this transform of the \
recurrence level at each stage."
endparam
}
```

Constructor Summary
`MMF_SwitchRecursion()`

`MMF_SwitchRecursion(Generic pparent)`

Method Summary
` float` `GetLowerBailout()`
Determine the lower bailout boundary.
` complex` `GetPrimaryExponent()`
Determine the primary exponent.
` float` `GetUpperBailout()`
Determine the upper bailout boundary.
` complex` `Init(complex pz)`
Note that here zold is initialised to initial z
` boolean` `IsBailedOut(complex pz)`
Test whether the formula has bailed out (i.e.
` complex` `Iterate(complex pz)`
Produce the next value in the sequence

Methods inherited from class mmf:MMF_SwitchConvergentDivergentFormula
`SetParams`

Methods inherited from class common:Generic
`GetParent`

Methods inherited from class Object

Constructor Detail

### MMF_SwitchRecursion

`public MMF_SwitchRecursion(Generic pparent)`
Parameters:
`pparent` - the parent, generally "this" for the parent, or zero

### MMF_SwitchRecursion

`public MMF_SwitchRecursion()`
Method Detail

### Init

`public complex Init(complex pz)`
Description copied from class: `MMF_SwitchConvergentDivergentFormula`
Note that here zold is initialised to initial z

What it's initialised to is normally irrelevant unless the derived formula uses zold in its main calculations in which case the user should be given the choice of initialising zold to either the location, the initial z value or a fixed constant.

Overrides:
`Init` in class `MMF_SwitchConvergentDivergentFormula`
Parameters:
`pz` - the location (normally #pixel)
Returns:
initial z for iteration

### Iterate

`public complex Iterate(complex pz)`
Description copied from class: `ConvergentDivergentFormula`
Produce the next value in the sequence

As long as the sequence has not bailed out, this function will be continually called to produce sequence values.

Overrides:
`Iterate` in class `ConvergentDivergentFormula`
Parameters:
`pz` - previous value in the sequence; corresponds to #z in a fractal formula. Note that you should always use this value for computing the next iteration, rather than a saved value, as the calling code may modify the returned value before passing it back to the next Iterate() call.
Returns:
the next value in the sequence

### IsBailedOut

`public boolean IsBailedOut(complex pz)`
Description copied from class: `ConvergentDivergentFormula`
Test whether the formula has bailed out (i.e. the sequence is complete)

Since this is a divergent fractal, the test is easy: if it's bigger than the bailout, the sequence is done.

Overrides:
`IsBailedOut` in class `ConvergentDivergentFormula`
Parameters:
`pz` - last sequence value to test; this should be the value returned from the previous Iterate() call. Note that it is acceptable to ignore pz and use m_BailedOut, but any code calling IsBailedOut() should pass in the correct pz for Formula classes which do not use m_BailedOut.
Returns:
true if the sequence has bailed out (i.e. should be terminated)

### GetUpperBailout

`public float GetUpperBailout()`
Description copied from class: `ConvergentDivergentFormula`
Determine the upper bailout boundary.

Overrides:
`GetUpperBailout` in class `ConvergentDivergentFormula`
Returns:
the upper bailout parameter

### GetLowerBailout

`public float GetLowerBailout()`
Description copied from class: `ConvergentDivergentFormula`
Determine the lower bailout boundary.

Overrides:
`GetLowerBailout` in class `ConvergentDivergentFormula`
Returns:
the lower bailout parameter

### GetPrimaryExponent

`public complex GetPrimaryExponent()`
Description copied from class: `Formula`
Determine the primary exponent.

Many fractals can be characterized by an exponent value that is useful to other formulas, so we provide that here. If your formula does not need or use this value, override the p_power parameter and make it hidden.

Overrides:
`GetPrimaryExponent` in class `Formula`
Returns:
the primary exponent parameter