// Mandelbrot pictures

//=====================

//

//   see https://en.wikipedia.org/wiki/Mandelbrot_set

// needs to be called with

//

//

import java.awt.image.BufferedImage

// complex numbers

  def +(that: Complex) = Complex(this.re + that.re, this.im + that.im)

  def -(that: Complex) = Complex(this.re - that.re, this.im - that.im)

  def *(that: Complex) = Complex(this.re * that.re - this.im * that.im,

                                 this.re * that.im + that.re * this.im)

  def *(that: Double) = Complex(this.re * that, this.im * that)

  def abs() = Math.sqrt(this.re * this.re + this.im * this.im)

}

object i extends Complex(0, 1)

// implicit conversion from Doubles to Complex

given Conversion[Double, Complex] = Complex(_, 0)

// some customn colours for the "sliding effect"

val colours = List(

// the viewer panel with an image canvas

class Viewer(width: Int, height: Int) extends JPanel {

    g.asInstanceOf[Graphics2D].drawImage(canvas, null, null)

  def clearCanvas(color: Color) = {

      canvas.setRGB(x, y, color.getRGB())

    repaint()

}

// initialising the viewer panel

def openViewer(width: Int, height: Int) : Viewer = {

  frame.add(viewer)

  frame.pack()

  frame.setVisible(true)

  frame.setResizable(false)

  frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE)

  viewer

}

// some hardcoded parameters

val W = 900   // width

val H = 800   // height

val black = Color.black

val viewer = openViewer(W, H)

// draw a pixel on the canvas

  viewer.canvas.setRGB(x, y, color.getRGB())

//   the iteration goes on for a maximum of max steps,

//   but might leave early when the pred is satisfied

def iterations(c: Complex, max: Int) : Int = {

  def pred(z: Complex) = z.abs() < 2    // exit condition

  LazyList.iterate(0.0 * i, max)(next).takeWhile(pred).size

}

//    max is the number of maximum iterations

def mandelbrot(start: Complex, end: Complex, max: Int) : Unit = {

  viewer.clearCanvas(black)

  val d_x = (end.re - start.re) / W

  val d_y = (end.im - start.im) / H

  for (y <- (0 until H).par) {

    for (x <- (0 until W).par) {

     val colour = 

     pixel(x, y, colour)

    }

    viewer.updateUI()

}

// Examples

//==========

//for measuring time

def time_needed[T](code: => T) = {

  val start = System.nanoTime()

  code

  val end = System.nanoTime()

  (end - start) / 1.0e9

}

// example 1

val exa1 = -2.0 + -1.5 * i

val exa2 =  1.0 +  1.5 * i

println(s"${time_needed(mandelbrot(exa1, exa2, 1000))} secs")

// example 2

val exb1 = -0.37465401 + 0.659227668 * i

val exb2 = -0.37332410 + 0.66020767 * i

//time_needed(mandelbrot(exb1, exb2, 1000))

// example 3

val exc1 = 0.435396403 + 0.367981352 * i

val exc2 = 0.451687191 + 0.380210061 * i

//time_needed(mandelbrot(exc1, exc2, 1000))

// some more computations with example 3

val delta = (exc2 - exc1) * 0.0333

println(s"${time_needed(

// Larry Paulson's example

val exl1 = -0.74364990 + 0.13188170 * i

val exl2 = -0.74291189 + 0.13261971 * i

//println(s"${time_needed(mandelbrot(exl1, exl2, 1000))} secs")

// example by Jorgen Villadsen

val exj1 = 0.10284 - 0.63275 * i

val exj2 = 0.11084 - 0.64075 * i

//time_needed(mandelbrot(exj1, exj2, 1000))

// another example

val exA = 0.3439274 + 0.6516478 * i

val exB = 0.3654477 + 0.6301795 * i

//time_needed(mandelbrot(exA, exB, 1000))