-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | relatively useful fractal functions
--   
--   A library for analysis and exploration of fractals, providing angled
--   internal addresses, external ray tracing, nucleus and bond point
--   finding, and iterations for images of the Mandelbrot Set.
@package ruff
@version 0.4.0.1


-- | Rational numbers with ruff-specific operations.
module Fractal.RUFF.Types.Ratio

-- | Rational numbers with ruff-specific operations.
class Q r where type Z r (%!) = (%) zero = 0 %! 1 half = 1 %! 2 one = 1 %! 1 fromQ x = toInteger (numerator x) %! toInteger (denominator x) toQ x = fromInteger (numerator x) %! fromInteger (denominator x) wrap x = (numerator x `mod` denominator x) %! denominator x doubleWrap = {-# SCC "doubleWrap" #-} (double . wrap) double x = {-# SCC "double" #-} (case () of { _ | even d -> (if n < d' then n else n - d') % d' | otherwise -> (if n' < d then n' else n' - d) %! d where d = denominator x d' = d `div` 2 n = numerator x n' = 2 * n }) doubleOdd x = {-# SCC "doubleOdd" #-} ((if n' < d then n' else n' - d) %! d) where d = denominator x n = numerator x n' = 2 * n preimages x = (n % d', (n + d) % d') where n = numerator x d = denominator x d' = 2 * d where {
    type family Z r;
}

-- | smart constuctor
(%) :: Q r => Z r -> Z r -> r

-- | extract numerator
numerator :: Q r => r -> Z r

-- | extract denominator
denominator :: Q r => r -> Z r

-- | unsafe constructor
(%!) :: Q r => Z r -> Z r -> r

-- | 0
zero :: (Q r, Integral (Z r)) => r

-- | 1/2
half :: (Q r, Integral (Z r)) => r

-- | 1
one :: (Q r, Integral (Z r)) => r

-- | convert to Prelude.Rational
fromQ :: (Q r, Integral (Z r)) => r -> Rational

-- | convert from Prelude.Rational
toQ :: (Q r, Integral (Z r)) => Rational -> r

-- | wrap into [0,1)
wrap :: (Q r, Integral (Z r)) => r -> r

-- | doubling map to [0,1)
doubleWrap :: (Q r, Integral (Z r)) => r -> r

-- | doubling map from [0,1) to [0,1)
double :: (Q r, Integral (Z r)) => r -> r

-- | doubling map from [0,1) to [0,1) for odd denominator
doubleOdd :: (Q r, Integral (Z r)) => r -> r

-- | doubling map preimages from [0,1) to [0,1)x[0,1)
preimages :: (Q r, Integral (Z r)) => r -> (r, r)

-- | Ratio data structure
data Ratio a
(:%) :: !a -> !a -> Ratio a

-- | Rational type
type Rational = Ratio Integer
instance Data.Data.Data a => Data.Data.Data (Fractal.RUFF.Types.Ratio.Ratio a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Fractal.RUFF.Types.Ratio.Ratio a)
instance GHC.Real.Integral a => Fractal.RUFF.Types.Ratio.Q (GHC.Real.Ratio a)
instance GHC.Real.Integral a => Fractal.RUFF.Types.Ratio.Q (Fractal.RUFF.Types.Ratio.Ratio a)
instance GHC.Real.Integral a => GHC.Classes.Ord (Fractal.RUFF.Types.Ratio.Ratio a)
instance (GHC.Real.Integral a, GHC.Read.Read a) => GHC.Read.Read (Fractal.RUFF.Types.Ratio.Ratio a)
instance (GHC.Real.Integral a, GHC.Show.Show a) => GHC.Show.Show (Fractal.RUFF.Types.Ratio.Ratio a)


-- | Complex numbers without the <a>RealFloat</a> constraint.
module Fractal.RUFF.Types.Complex

-- | Complex number type without the <a>RealFloat</a> constraint.
data Complex r
(:+) :: !r -> !r -> Complex r

-- | Complex number with magnitude 1 and the given phase.
cis :: Floating r => r -> Complex r

-- | Complex number with the given magnitude and phase.
mkPolar :: Floating r => r -> r -> Complex r

-- | Extract the real part.
realPart :: Complex r -> r

-- | Extract the imaginary part.
imagPart :: Complex r -> r

-- | Complex conjugate.
conjugate :: Num r => Complex r -> Complex r

-- | Complex magnitude squared.
magnitude2 :: Num r => Complex r -> r

-- | Complex magnitude.
magnitude :: Floating r => Complex r -> r

-- | Complex phase.
phase :: (Ord r, Floating r) => Complex r -> r

-- | Convert to polar form.
polar :: (Ord r, Floating r) => Complex r -> (r, r)
instance Data.Data.Data r => Data.Data.Data (Fractal.RUFF.Types.Complex.Complex r)
instance GHC.Classes.Eq r => GHC.Classes.Eq (Fractal.RUFF.Types.Complex.Complex r)
instance GHC.Show.Show r => GHC.Show.Show (Fractal.RUFF.Types.Complex.Complex r)
instance GHC.Read.Read r => GHC.Read.Read (Fractal.RUFF.Types.Complex.Complex r)
instance GHC.Num.Num r => GHC.Num.Num (Fractal.RUFF.Types.Complex.Complex r)
instance GHC.Real.Fractional r => GHC.Real.Fractional (Fractal.RUFF.Types.Complex.Complex r)
instance (GHC.Classes.Ord r, GHC.Float.Floating r) => GHC.Float.Floating (Fractal.RUFF.Types.Complex.Complex r)
instance Data.Vec.LinAlg.NearZero r => Data.Vec.LinAlg.NearZero (Fractal.RUFF.Types.Complex.Complex r)


-- | External angles define external rays which can be traced back from the
--   circle at infinity to parameters near the boundary of the Mandelbrot
--   Set. Conversely, parameters near the boundary of the Mandelbrot Set
--   can be traced outwards to compute external angles.
module Fractal.RUFF.Mandelbrot.Ray

-- | Compute the external ray for an external angle with a given accuracy,
--   sharpness and starting radius. For example:
--   
--   <pre>
--   externalRay 1e-10 8 (2**24) (1/3)
--   </pre>
--   
--   The algorithm is based on Tomoki Kawahira's paper <i>An algorithm to
--   draw external rays of the Mandelbrot set</i>
--   <a>http://www.math.nagoya-u.ac.jp/~kawahira/programs/mandel-exray.pdf</a>.
externalRay :: (Ord r, Floating r) => r -> Int -> r -> Rational -> [Complex r]

-- | Compute the external ray outwards from a given parameter value. If the
--   result <tt>rs</tt> satisfies:
--   
--   <pre>
--   c = last rs
--   magnitude c &gt; radius
--   </pre>
--   
--   then the external angle is given by <tt>t</tt>:
--   
--   <pre>
--   a = phase c / (2 * pi)
--   t = a - fromIntegral (floor a)
--   </pre>
externalRayOut :: (Ord r, Floating r, RealFrac r) => Int -> r -> r -> Int -> r -> Complex r -> [Complex r]


-- | Mu-atom period, nucleus and bond point finding.
module Fractal.RUFF.Mandelbrot.Nucleus

-- | Find the period of the lowest period nucleus inside a square.
--   
--   The algorithm is based on Robert Munafo's page, <i>Finding the Period
--   of a mu-Atom</i> <a>http://mrob.com/pub/muency/period.html</a>.
findPeriod :: (Floating r, Ord r) => Int -> r -> Complex r -> Maybe Int

-- | Given the period and approximate location, successively refine this
--   estimate to a nucleus.
--   
--   The algorithm is based on Robert Munafo's page <i>Newton-Raphson
--   method</i> <a>http://mrob.com/pub/muency/newtonraphsonmethod.html</a>.
findNucleus :: (Floating r, Fractional r) => Int -> Complex r -> [Complex r]

-- | Given the period and nucleus, find succesive refinements to the bond
--   point at a given internal angle.
--   
--   The algorithm is based on ideas from
--   <a>http://mrob.com/pub/muency/derivative.html</a>.
findBond :: (Floating r, Fractional r) => Int -> Complex r -> r -> [Complex r]

-- | Given the period and nucleus, find an interior point at a given
--   internal angle and radius in (0,1].
findInternal :: (Floating r, Fractional r) => Int -> Complex r -> r -> r -> [Complex r]


-- | Generic (slow) functions to iterate points.
module Fractal.RUFF.Mandelbrot.Iterate

-- | Iteration mode.
data Mode
Simple :: Mode
EscapeTime :: Mode
DistanceEstimate :: Mode

-- | Iteration state.
data Iterate u r
IterSimple :: !(Complex r) -> !u -> Iterate u r
[itc, itz] :: Iterate u r -> !(Complex r)
[iterUser] :: Iterate u r -> !u
IterEscapeTime :: !(Complex r) -> !Int -> !u -> Iterate u r
[itc, itz] :: Iterate u r -> !(Complex r)
[itn] :: Iterate u r -> !Int
[iterUser] :: Iterate u r -> !u
IterDistanceEstimate :: !(Complex r) -> !Int -> !u -> Iterate u r
[itc, itz, itdz] :: Iterate u r -> !(Complex r)
[itn] :: Iterate u r -> !Int
[iterUser] :: Iterate u r -> !u

-- | Iteration output.
data Output u r
OutSimple :: !u -> Output u r
[outUser] :: Output u r -> !u
OutEscapeTime :: !r -> !u -> Output u r
[escapeTime, finalAngle] :: Output u r -> !r
[outUser] :: Output u r -> !u
OutDistanceEstimate :: !r -> !u -> Output u r
[escapeTime, finalAngle, distanceEstimate] :: Output u r -> !r
[outUser] :: Output u r -> !u

-- | Iteration initial state.
initial :: Num r => Mode -> u -> Complex r -> Iterate u r

-- | Iteration engine.
iterate :: (Ord r, Floating r) => Int -> Iterate u r -> Either (Iterate u r) (Output u r)

-- | Iterate over a list.
iterates :: (Functor m, Monad m, Ord r, Floating r) => Int -> [Iterate u r] -> (Output u r -> m ()) -> m [Iterate u r]
instance (Data.Data.Data r, Data.Data.Data u) => Data.Data.Data (Fractal.RUFF.Mandelbrot.Iterate.Output u r)
instance (GHC.Classes.Ord r, GHC.Classes.Ord u) => GHC.Classes.Ord (Fractal.RUFF.Mandelbrot.Iterate.Output u r)
instance (GHC.Classes.Eq r, GHC.Classes.Eq u) => GHC.Classes.Eq (Fractal.RUFF.Mandelbrot.Iterate.Output u r)
instance (GHC.Show.Show r, GHC.Show.Show u) => GHC.Show.Show (Fractal.RUFF.Mandelbrot.Iterate.Output u r)
instance (GHC.Read.Read r, GHC.Read.Read u) => GHC.Read.Read (Fractal.RUFF.Mandelbrot.Iterate.Output u r)
instance (Data.Data.Data r, Data.Data.Data u) => Data.Data.Data (Fractal.RUFF.Mandelbrot.Iterate.Iterate u r)
instance (GHC.Classes.Eq u, GHC.Classes.Eq r) => GHC.Classes.Eq (Fractal.RUFF.Mandelbrot.Iterate.Iterate u r)
instance (GHC.Show.Show u, GHC.Show.Show r) => GHC.Show.Show (Fractal.RUFF.Mandelbrot.Iterate.Iterate u r)
instance (GHC.Read.Read u, GHC.Read.Read r) => GHC.Read.Read (Fractal.RUFF.Mandelbrot.Iterate.Iterate u r)
instance Data.Data.Data Fractal.RUFF.Mandelbrot.Iterate.Mode
instance GHC.Enum.Bounded Fractal.RUFF.Mandelbrot.Iterate.Mode
instance GHC.Enum.Enum Fractal.RUFF.Mandelbrot.Iterate.Mode
instance GHC.Classes.Ord Fractal.RUFF.Mandelbrot.Iterate.Mode
instance GHC.Classes.Eq Fractal.RUFF.Mandelbrot.Iterate.Mode
instance GHC.Show.Show Fractal.RUFF.Mandelbrot.Iterate.Mode
instance GHC.Read.Read Fractal.RUFF.Mandelbrot.Iterate.Mode


-- | Generic (slow) functions to render images.
module Fractal.RUFF.Mandelbrot.Image

-- | Render an image with the <a>Simple</a> algorithm. The iteration count
--   is doubled until the image is good enough, or the fixed maximum
--   iteration count is reached.
--   
--   <pre>
--   putStr . unicode $ simpleImage (coordinates 100 100 ((-1.861):+0) (0.001)) 1000000000
--   </pre>
simpleImage :: (Ord r, Floating r) => Coordinates r -> Int -> UArray (Int, Int) Bool

-- | Render an image with the <a>DistanceEstimate</a> algorithm. The
--   iteration count is doubled until the image is good enough, or the
--   fixed maximum iteration count is reached. The output values are
--   converted to <a>Float</a>.
--   
--   <pre>
--   putStr . unicode . border $ complexImage (coordinates 100 100 ((-1.861):+0) (0.001)) 1000000000
--   </pre>
complexImage :: (Ord r, Real r, Floating r) => Coordinates r -> Int -> UArray (Int, Int, Channel) Float

-- | Image rendering loop.
imageLoop :: (Ord r, Floating r) => STRef s Int -> a -> Int -> Int -> Bool -> Int -> [Iterate u r] -> (Output u r -> ST s ()) -> ST s a

-- | The parameter plane coordinates for an image, with bounds.
coordinates :: (Ord r, Floating r) => Int -> Int -> Complex r -> r -> Coordinates r

-- | Convert a bit array to ascii graphics.
ascii :: UArray (Int, Int) Bool -> String

-- | Convert a bit array to unicode block graphics.
unicode :: UArray (Int, Int) Bool -> String

-- | Channels in an image.
data Channel

-- | continuous dwell
EscapeTime :: Channel

-- | normalized to pixel spacing
DistanceEstimate' :: Channel

-- | in [-pi,pi]
FinalAngle :: Channel

-- | Image bounds and coordinates.
type Coordinates r = (((Int, Int), (Int, Int)), [(Pair Int Int, Complex r)])

-- | Convert a distance estimate image to a near-boundary bit array. The
--   input image must have a DistanceEstimate' channel.
border :: UArray (Int, Int, Channel) Float -> UArray (Int, Int) Bool
instance Data.Data.Data Fractal.RUFF.Mandelbrot.Image.Channel
instance GHC.Show.Show Fractal.RUFF.Mandelbrot.Image.Channel
instance GHC.Read.Read Fractal.RUFF.Mandelbrot.Image.Channel
instance GHC.Arr.Ix Fractal.RUFF.Mandelbrot.Image.Channel
instance GHC.Enum.Bounded Fractal.RUFF.Mandelbrot.Image.Channel
instance GHC.Enum.Enum Fractal.RUFF.Mandelbrot.Image.Channel
instance GHC.Classes.Ord Fractal.RUFF.Mandelbrot.Image.Channel
instance GHC.Classes.Eq Fractal.RUFF.Mandelbrot.Image.Channel


-- | External angles give rise to kneading sequences under the angle
--   doubling map. Internal addresses encode kneading sequences in
--   human-readable form, when extended to angled internal addresses they
--   distinguish hyperbolic components in a concise and meaningful way.
--   
--   The algorithms are mostly based on Dierk Schleicher's papers
--   <i>Internal Addresses Of The Mandelbrot Set And Galois Groups Of
--   Polynomials (version of February 5, 2008)</i>
--   <a>http://arxiv.org/abs/math/9411238v2</a> and <i>Rational parameter
--   rays of the Mandelbrot set (version of August 11, 1998)</i>
--   <a>http://arxiv.org/abs/math/9711213v2</a>.
module Fractal.RUFF.Mandelbrot.Address

-- | Angle as a fraction of a turn, usually in [0, 1).
type Angle = Rational

-- | Tuning transformation for angles. Probably only valid for angle pairs
--   representing hyperbolic components.
tune :: Angle -> (Angle, Angle) -> Angle

-- | Convert to human readable form.
prettyAngle :: Angle -> String

-- | Convert to human readable form.
prettyAngles :: [Angle] -> String

-- | All external angles landing at the same location as the given external
--   angle.
angles :: Angle -> [Angle]

-- | Binary representation of a (pre-)periodic angle.
type BinAngle = ([Bool], [Bool])

-- | Convert an angle to binary representation.
binary :: Angle -> BinAngle

-- | Convert an angle from binary representation.
unbinary :: BinAngle -> Angle

-- | Tuning transformation for binary represented periodic angles. Probably
--   only valid for angle pairs representing hyperbolic components.
btune :: BinAngle -> (BinAngle, BinAngle) -> BinAngle

-- | Convert to human readable form.
prettyBinAngle :: BinAngle -> String

-- | Convert from human readable form.
parseBinAngle :: String -> Maybe BinAngle

-- | Period under angle doubling.
bperiod :: BinAngle -> Int

-- | Preperiod under angle doubling.
bpreperiod :: BinAngle -> Int

-- | All external angles landing at the same location as the given external
--   angle (binary angle variant).
bangles :: BinAngle -> [BinAngle]

-- | Elements of kneading sequences.
data Knead
Zero :: Knead
One :: Knead
Star :: Knead

-- | Knead character representation.
kneadChar :: Knead -> Char

-- | Kneading sequences. Note that the <a>Aperiodic</a> case has an
--   infinite list.
data Kneading
Aperiodic :: [Knead] -> Kneading
PrePeriodic :: [Knead] -> [Knead] -> Kneading
StarPeriodic :: [Knead] -> Kneading
Periodic :: [Knead] -> Kneading

-- | Kneading sequence as a string. The <a>Aperiodic</a> case is truncated
--   arbitrarily.
prettyKneading :: Kneading -> String

-- | The kneading sequence for an external angle.
kneading :: Angle -> Kneading

-- | The period of a kneading sequence, or <a>Nothing</a> when it isn't
--   periodic.
period :: Kneading -> Maybe Int

-- | Unwrap a kneading sequence to an infinite list.
unwrap :: Kneading -> [Knead]

-- | A star-periodic kneading sequence's upper and lower associated
--   kneading sequences.
associated :: Kneading -> Maybe (Kneading, Kneading)

-- | The upper associated kneading sequence.
upper :: Kneading -> Maybe Kneading

-- | The lower associated kneading sequence.
lower :: Kneading -> Maybe Kneading

-- | Internal addresses are a non-empty sequence of strictly increasing
--   integers beginning with '1'.
data InternalAddress
InternalAddress :: [Int] -> InternalAddress

-- | Internal address as a string.
prettyInternalAddress :: InternalAddress -> String

-- | Construct an <a>InternalAddress</a> from a kneading sequence.
internalAddress :: Kneading -> Maybe InternalAddress

-- | Construct a valid <a>InternalAddress</a>, checking the precondition.
internalFromList :: [Int] -> Maybe InternalAddress

-- | Extract the sequence of integers.
internalToList :: InternalAddress -> [Int]

-- | Angled internal addresses have angles between each integer in an
--   internal address.
data AngledInternalAddress
Unangled :: Int -> AngledInternalAddress
Angled :: Int -> Angle -> AngledInternalAddress -> AngledInternalAddress

-- | Angled internal address as a string.
prettyAngledInternalAddress :: AngledInternalAddress -> String

-- | The angled internal address corresponding to an external angle.
angledInternalAddress :: Angle -> Maybe AngledInternalAddress

-- | Builds a valid <a>AngledInternalAddress</a> from a list, checking the
--   precondition that only the last 'Maybe Angle' should be
--   <a>Nothing</a>, and the <a>Integer</a> must be strictly increasing.
angledFromList :: [(Int, Maybe Angle)] -> Maybe AngledInternalAddress

-- | Convert an <a>AngledInternalAddress</a> to a list.
angledToList :: AngledInternalAddress -> [(Int, Maybe Angle)]

-- | The pair of external angles whose rays land at the root of the
--   hyperbolic component described by the angled internal address.
externalAngles :: AngledInternalAddress -> Maybe (Angle, Angle)

-- | Discard angle information from an internal address.
stripAngles :: AngledInternalAddress -> InternalAddress

-- | Split an angled internal address at the last island.
splitAddress :: AngledInternalAddress -> (AngledInternalAddress, [Angle])

-- | The inverse of <a>splitAddress</a>.
joinAddress :: AngledInternalAddress -> [Angle] -> AngledInternalAddress

-- | The period of an angled internal address.
addressPeriod :: AngledInternalAddress -> Int

-- | Parse an angle.
parseAngle :: String -> Maybe Angle

-- | Parse a list of angles.
parseAngles :: String -> Maybe [Angle]

-- | Parse a kneading element.
parseKnead :: String -> Maybe Knead

-- | Parse a non-aperiodic kneading sequence.
parseKneading :: String -> Maybe Kneading

-- | Parse an internal address.
parseInternalAddress :: String -> Maybe InternalAddress

-- | Parse an angled internal address, accepting some unambiguous
--   abbreviations.
parseAngledInternalAddress :: String -> Maybe AngledInternalAddress
instance Data.Data.Data Fractal.RUFF.Mandelbrot.Address.AngledInternalAddress
instance GHC.Classes.Ord Fractal.RUFF.Mandelbrot.Address.AngledInternalAddress
instance GHC.Classes.Eq Fractal.RUFF.Mandelbrot.Address.AngledInternalAddress
instance GHC.Show.Show Fractal.RUFF.Mandelbrot.Address.AngledInternalAddress
instance GHC.Read.Read Fractal.RUFF.Mandelbrot.Address.AngledInternalAddress
instance Data.Data.Data Fractal.RUFF.Mandelbrot.Address.InternalAddress
instance GHC.Classes.Ord Fractal.RUFF.Mandelbrot.Address.InternalAddress
instance GHC.Classes.Eq Fractal.RUFF.Mandelbrot.Address.InternalAddress
instance GHC.Show.Show Fractal.RUFF.Mandelbrot.Address.InternalAddress
instance GHC.Read.Read Fractal.RUFF.Mandelbrot.Address.InternalAddress
instance Data.Data.Data Fractal.RUFF.Mandelbrot.Address.Kneading
instance GHC.Classes.Ord Fractal.RUFF.Mandelbrot.Address.Kneading
instance GHC.Classes.Eq Fractal.RUFF.Mandelbrot.Address.Kneading
instance GHC.Show.Show Fractal.RUFF.Mandelbrot.Address.Kneading
instance GHC.Read.Read Fractal.RUFF.Mandelbrot.Address.Kneading
instance Data.Data.Data Fractal.RUFF.Mandelbrot.Address.Knead
instance GHC.Enum.Bounded Fractal.RUFF.Mandelbrot.Address.Knead
instance GHC.Enum.Enum Fractal.RUFF.Mandelbrot.Address.Knead
instance GHC.Classes.Ord Fractal.RUFF.Mandelbrot.Address.Knead
instance GHC.Classes.Eq Fractal.RUFF.Mandelbrot.Address.Knead
instance GHC.Show.Show Fractal.RUFF.Mandelbrot.Address.Knead
instance GHC.Read.Read Fractal.RUFF.Mandelbrot.Address.Knead


-- | Mu-atom coordinate and address algorithms.
module Fractal.RUFF.Mandelbrot.Atom

-- | Mu-atom properties.
data MuAtom r
MuAtom :: !(Complex r) -> !Double -> !Double -> !Int -> MuAtom r
[muNucleus] :: MuAtom r -> !(Complex r)
[muSize] :: MuAtom r -> !Double
[muOrient] :: MuAtom r -> !Double
[muPeriod] :: MuAtom r -> !Int

-- | Progress updates for <a>findAtom</a>.
data FindAtom r
AtomSplitTodo :: FindAtom r
AtomSplitDone :: AngledInternalAddress -> [Angle] -> FindAtom r
AtomAnglesTodo :: FindAtom r
AtomAnglesDone :: !Angle -> !Angle -> FindAtom r
AtomRayTodo :: FindAtom r
AtomRay :: !Int -> FindAtom r
AtomRayDone :: !(Complex r) -> FindAtom r
AtomNucleusTodo :: FindAtom r
AtomNucleus :: !Int -> FindAtom r
AtomNucleusDone :: !(Complex r) -> FindAtom r
AtomBondTodo :: FindAtom r
AtomBond :: !Int -> FindAtom r
AtomBondDone :: !(Complex r) -> FindAtom r
AtomSuccess :: !(MuAtom r) -> FindAtom r
AtomFailed :: FindAtom r

-- | Try to find an atom, providing progress updates.
findAtom :: (Floating r, NearZero r, Real r) => AngledInternalAddress -> [FindAtom r]

-- | Find the first success in the progress list.
findAtom' :: [FindAtom r] -> Maybe (MuAtom r)

-- | Find an atom from its address.
findAtom_ :: (Floating r, NearZero r, Real r) => AngledInternalAddress -> Maybe (MuAtom r)

-- | Progress updates for <a>findAddress</a>.
data FindAddress r
AddressCuspTodo :: FindAddress r
AddressCuspDone :: !(Complex r) -> FindAddress r
AddressDwellTodo :: FindAddress r
AddressDwell :: !Int -> FindAddress r
AddressDwellDone :: !Int -> FindAddress r
AddressRayOutTodo :: FindAddress r
AddressRayOut :: !Double -> FindAddress r
AddressRayOutDone :: !(Complex r) -> FindAddress r
AddressExternalTodo :: FindAddress r
AddressExternalDone :: !Angle -> FindAddress r
AddressAddressTodo :: FindAddress r
AddressSuccess :: AngledInternalAddress -> FindAddress r
AddressFailed :: FindAddress r

-- | Try to find an address, providing progress updates.
findAddress :: (Floating r, NearZero r, Real r, RealFrac r) => MuAtom r -> [FindAddress r]

-- | Find the first success in the progress list.
findAddress' :: [FindAddress r] -> Maybe AngledInternalAddress

-- | Find an address for a mu-atom.
findAddress_ :: (Floating r, NearZero r, Real r, RealFrac r) => MuAtom r -> Maybe AngledInternalAddress

-- | Progress updates for <a>locate</a>.
data Locate r
LocateScanTodo :: Locate r
LocateScan :: Locate r
LocateScanDone :: !Int -> Locate r
LocateNucleusTodo :: Locate r
LocateNucleus :: !Int -> Locate r
LocateNucleusDone :: !(Complex r) -> Locate r
LocateBondTodo :: Locate r
LocateBond :: !Int -> Locate r
LocateBondDone :: !(Complex r) -> Locate r
LocateSuccess :: !(MuAtom r) -> Locate r
LocateFailed :: Locate r

-- | Try to find an atom close to a coordinate, providing progress updates.
locate :: (Floating r, NearZero r, Real r) => Complex r -> Double -> [Locate r]

-- | Find the first success in the progress list.
locate' :: [Locate r] -> Maybe (MuAtom r)

-- | Find an atom close to a coordinate.
locate_ :: (Floating r, NearZero r, Real r) => Complex r -> Double -> Maybe (MuAtom r)
instance GHC.Classes.Eq r => GHC.Classes.Eq (Fractal.RUFF.Mandelbrot.Atom.Locate r)
instance GHC.Show.Show r => GHC.Show.Show (Fractal.RUFF.Mandelbrot.Atom.Locate r)
instance GHC.Read.Read r => GHC.Read.Read (Fractal.RUFF.Mandelbrot.Atom.Locate r)
instance GHC.Classes.Eq r => GHC.Classes.Eq (Fractal.RUFF.Mandelbrot.Atom.FindAddress r)
instance GHC.Show.Show r => GHC.Show.Show (Fractal.RUFF.Mandelbrot.Atom.FindAddress r)
instance GHC.Read.Read r => GHC.Read.Read (Fractal.RUFF.Mandelbrot.Atom.FindAddress r)
instance GHC.Classes.Eq r => GHC.Classes.Eq (Fractal.RUFF.Mandelbrot.Atom.FindAtom r)
instance GHC.Show.Show r => GHC.Show.Show (Fractal.RUFF.Mandelbrot.Atom.FindAtom r)
instance GHC.Read.Read r => GHC.Read.Read (Fractal.RUFF.Mandelbrot.Atom.FindAtom r)
instance GHC.Classes.Eq r => GHC.Classes.Eq (Fractal.RUFF.Mandelbrot.Atom.MuAtom r)
instance GHC.Show.Show r => GHC.Show.Show (Fractal.RUFF.Mandelbrot.Atom.MuAtom r)
instance GHC.Read.Read r => GHC.Read.Read (Fractal.RUFF.Mandelbrot.Atom.MuAtom r)