## mmf Class MMF_SwitchNova

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

`class MMF_SwitchConvergentDivergentFormula:MMF_SwitchNova`

Object version of NovaMandel for switching
Nova fractal (Mandelbrot form), a modified Newtonian-style fractal.
Object switch version by David Makin
Originators Damien M. Jones, Paul Derbyshire

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_SwitchNova(MMF_SwitchConvergentDivergentFormula) {
;
; Object version of NovaMandel for switching<br>
;
; Nova fractal (Mandelbrot form), a modified Newtonian-style fractal.<br>
; Object switch version by David Makin<br>
;
; Originators Damien M. Jones, Paul Derbyshire<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_SwitchNova(Generic pparent)
MMF_SwitchConvergentDivergentFormula.MMF_SwitchConvergentDivergentFormula(pparent)
endfunc

; Note that here if the formula is in Mandelbrot mode then one is added
; to the start value by default.
; @param f flag, true for Mandelbrot mode, false for Julia mode
; @param v either the start value or the constant
func SetParams(bool f,complex v)
if !@p_manual
if (fType = f)
fValue = fConstant = v + 1.0
else
fValue = fConstant = v
endif
endif
endfunc

complex func Init(complex pz)
complex zz = MMF_SwitchConvergentDivergentFormula.Init(pz)
pm1 = fConstant - 1.0
endif
return zz
endfunc

complex func Iterate(complex pz)
MMF_SwitchConvergentDivergentFormula.Iterate(pz)
if @p_power == (3, 0)  ; special optimized routine for power 3
complex zsquared = sqr(pz)
return pz - @relax * (zsquared*pz-1.0) / (3.0*zsquared) + fConstant
else
return pz - @relax * (pz^@p_power-1.0) \
/ (@p_power * pz^(@p_power-1.0)) + fConstant
endif
elseif @p_switch=="Exponent"
return pz - @relax * (pz^fConstant-1.0) \
/ (fConstant * pz^pm1) + @p_seed1
else;if @p_switch=="Relaxation"
return pz - fConstant * (pz^@p_power-1.0) \
/ (@p_power * pz^(@p_power-1.0)) + @p_seed1
endif
endfunc

bool func IsBailedOut(complex pz)
if ((@p_BailType=="Divergent" || @p_BailType=="Both") \
&& |pz|>@p_bailout1) \
|| ((@p_BailType=="Convergent" || @p_BailType=="Both") \
&& |pz-m_ZOld|<@p_bailout)
m_BailedOut = true
endif
return m_BailedOut
endfunc

float func GetUpperBailout()
return @p_bailout1
endfunc

float func GetLowerBailout()
return @p_bailout
endfunc

private:
complex pm1

default:
title = "Switch Nova"
rating = recommended
float param p_lowerbailout
visible = false
endparam
float param p_upperbailout
visible = false
endparam
complex param p_start
caption = "Mandelbrot Start Value"
default = (1,0)
visible = @p_manual && @p_mandy
endparam
complex param p_seed
caption = "Julia Seed"
default = (0,0)
visible = @p_manual && !@p_mandy
endparam
caption = "Information"
text = "It should be noted that when using the Mandelbrot Start \
Value from a parent switching formula 1 is added to the \
value since generally the parental default will be (0,0) \
and the standard start value for Nova is (1,0)."
enabled = false
default = false
hint = "When enabled you can choose which variable is switchable."
endparam
int param p_switch
caption = "Switch Value"
enum = "Normal" "Exponent" "Relaxation"
default = 2
hint = "In 'Normal' mode the additive constant is the switchable \
variable, in the other modes the relevant values are made \
endparam
complex param p_seed1
caption = "Seed"
default = (-0.4,0.425)
endparam
complex param p_power
caption = "Exponent"
default = (3,0)
hint = "Overall exponent for the equation. The value (3,0) gives \
the classic Nova fractals."
endparam
complex param relax
caption = "Relaxation"
default = (1,0)
hint = "This can be used to slow down the convergence of \
the formula."
endparam
int param p_BailType
caption = "Bailout Type"
enum = "Divergent" "Convergent" "Both"
default = 1
endparam
float param p_bailout
caption = "Convergent Bailout"
default = 0.00001
exponential = true
hint = "Convergent bailout value; smaller values will cause more \
iterations to be done for each point."
visible = @p_BailType>0
endparam
float param p_bailout1
caption = "Divergent Bailout"
default = 1e20
exponential = true
hint = "Divergent bailout value; it's best to use large values to \
avoid erroneous detection of divergent bailout in convergent \
areas."
visible = @p_BailType!=1
endparam
}
```

Constructor Summary
`MMF_SwitchNova()`

`MMF_SwitchNova(Generic pparent)`

Method Summary
` float` `GetLowerBailout()`
Determine the lower bailout boundary.
` 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
` void` ```SetParams(boolean f, complex v)```
Note that here if the formula is in Mandelbrot mode then one is added to the start value by default.

Methods inherited from class common:Formula
`GetPrimaryExponent`

Methods inherited from class common:Generic
`GetParent`

Methods inherited from class Object

Constructor Detail

### MMF_SwitchNova

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

### MMF_SwitchNova

`public MMF_SwitchNova()`
Method Detail

### SetParams

```public void SetParams(boolean f,
complex v)```
Note that here if the formula is in Mandelbrot mode then one is added to the start value by default.

Overrides:
`SetParams` in class `MMF_SwitchConvergentDivergentFormula`
Parameters:
`f` - flag, true for Mandelbrot mode, false for Julia mode
`v` - either the start value or the constant

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