## Standard Class Standard_Magnet2Julia

```Object
common:Generic
common:Formula
common:ConvergentDivergentFormula
Standard:Standard_Magnet2Julia
```

`class ConvergentDivergentFormula:Standard_Magnet2Julia`

Object version of Julia in Standard.ufm. Magnetic Julia set type 2.

Ultra Fractal Source
``` class Standard_Magnet2Julia(common.ulb:ConvergentDivergentFormula) {
;
; Object version of Julia in Standard.ufm.
; Magnetic Julia set type 2.
;
public:
complex func Init(complex pz)
ConvergentDivergentFormula.Init(pz)
return pz
endfunc

complex func Iterate(complex pz)
ConvergentDivergentFormula.Iterate(pz)
return sqr( (pz^3 + 3 * (@p1-1) * pz + (@p1-1) * (@p1-2))  /            \
(3 * pz^2 + 3 * (@p1-2) * pz + (@p1-1) * (@p1-2) + 1) )
endfunc

default:
title = "Magnet 2 (Julia)"
helpfile = "Uf*.chm"
helptopic = "Html/formulas/standard/magnet.html"
param p1
caption = "Parameter"
default = (0, 0)
hint = "This parameter defines the shape of the fractal. Use the Switch \
feature in combination with the Magnet 2 (Mandelbrot) formula to \
find interesting values."
endparam
param p_upperbailout ; Overrides p_upperbailout from ConvergentDivergentFormula
caption = "Bailout value"
default = 100.0
min = 1
exponential = true
hint = "This parameter defines how soon an orbit bails out while \
iterating. Larger values give smoother outlines; smaller values \
generally produce more interesting shapes around the set."
endparam
param p_lowerbailout ; Overrides p_lowerbailout from ConvergentDivergentFormula
caption = "Convergent bailout value"
default = 0.000008
min = 0
exponential = true
hint = "This parameter defines how soon a convergent orbit bails out while \
iterating. Smaller values give more precise results but usually \
require more iterations."
endparam
complex param p_power ; Hide p_power from Formula
visible = false
endparam
}
```

Constructor Summary
`Standard_Magnet2Julia()`

Method Summary
` complex` `Init(complex pz)`
Set up for a sequence of values
` complex` `Iterate(complex pz)`
Produce the next value in the sequence

Methods inherited from class common:ConvergentDivergentFormula
`GetLowerBailout, GetUpperBailout, IsBailedOut`

Methods inherited from class common:Formula
`GetPrimaryExponent`

Methods inherited from class common:Generic
`GetParent`

Methods inherited from class Object

Constructor Detail

### Standard_Magnet2Julia

`public Standard_Magnet2Julia()`
Method Detail

### Init

`public complex Init(complex pz)`
Description copied from class: `ConvergentDivergentFormula`
Set up for a sequence of values

This function will be called at the beginning of each sequence of values (e.g. at the beginning of each fractal orbit).

Overrides:
`Init` in class `ConvergentDivergentFormula`
Parameters:
`pz` - seed value for the sequence; for a normal fractal formula, this will be #pixel
Returns:
first value in the sequence; this corresponds to #z in a fractal formula

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