ui

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

var Randomized : Boolean

def asInstanceOf [T0] : T0

def background : Color

def background_= (c: Color): Unit

def bounds : Rectangle

def clone (): AnyRef

def contents : Seq[Component]

def contents_= (c: Component): Unit

def cursor : Cursor

def cursor_= (c: Cursor): Unit

def deafTo (ps: Publisher*): Unit

def displayable : Boolean

def eq (arg0: AnyRef): Boolean

def equals (that: Any): Boolean

def finalize (): Unit

def flip : Boolean

returns a randomly chosen boolean (50%-50%)

def font : Font

def font_= (f: Font): Unit

def foreground : Color

def foreground_= (c: Color): Unit

def getClass (): java.lang.Class[_]

def getRandomPermutation (N: Int): Iterator[Int]

returns a random permutation of the integers in [0; N]

def hashCode (): Int

def ignoreRepaint : Boolean

def ignoreRepaint_= (b: Boolean): Unit

def init (): Unit

def isInstanceOf [T0] : Boolean

def listenTo (ps: Publisher*): Unit

val listeners : RefSet[Reaction] { val underlying: scala.collection.mutable.HashSet[scala.ref.Reference[scala.swing.Reactions.Reaction]] }

def locale : Locale

def location : Point

def locationOnScreen : Point

def maximumSize : Dimension

def maximumSize_= (x: Dimension): Unit

def minimumSize : Dimension

def minimumSize_= (x: Dimension): Unit

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

def onFirstSubscribe (): Unit

def onLastUnsubscribe (): Unit

def peer : Applet

def preferredSize : Dimension

def preferredSize_= (x: Dimension): Unit

def publish (e: Event): Unit

def reInitGrid (): Unit

val reactions : Reactions

def repaint (rect: Rectangle): Unit

def repaint (): Unit

def resetProblem (n: Int): Unit

def selectFirst [R] (r: Iterable[R], st: (R) ⇒ Boolean): R

return the first element r that is allowed: st(r) is true

def selectFirst2 [R, S] (r: Iterable[R], s: Iterable[S], st: (R, S) ⇒ Boolean): (R, S)

return the first couple of elements (r,s) that is allowed: st(r) is true the order is lexicographic

def selectFrom [R] (r: Iterable[R], st: (R) ⇒ Boolean): R

return an element r that is allowed: st(r) is true this selector is randomized; in case of tie breaks the returned one is chosen randomly

def selectFrom2 [R, S] (r: Iterable[R], s: Iterable[S], st: (R, S) ⇒ Boolean): (R, S)

return a couple (r,s) of elements r that is allowed: st(r,s) is true this selector is randomized; in case of tie breaks the returned one is chosen randomly

def selectFromRange (r: Range): Int

return an element of the range.

def selectMax [R] (r: Iterable[R], f: (R) ⇒ Int, st: (R) ⇒ Boolean): R

return an element r that is allowed: st(r) is true, and maximizing f(r) among the allowed couples this selector is randomized; in case of tie breaks the returned one is chosen randomly

def selectMax2 [R, S] (r: Iterable[R], s: Iterable[S], f: (R, S) ⇒ Int, st: (R, S) ⇒ Boolean): (R, S)

return a couple (r,s) that is allowed: st(r,s) is true, and maximizing f(r,s) among the allowed couples this selector is randomized; in case of tie breaks the returned one is chosen randomly

def selectMaxNR [R] (r: Iterable[R], f: (R) ⇒ Int, st: (R) ⇒ Boolean): R

return an element r that is allowed: st(r) is true, and maximizing f(r) among the allowed couples this selector is not randomized; in case of tie breaks the first one is returned

def selectMaxNR2 [R, S] (r: Iterable[R], s: Iterable[S], f: (R, S) ⇒ Int, st: (R, S) ⇒ Boolean): (R, S)

return a couple (r,s) that is allowed: st(r,s) is true, and maximizing f(r,s) among the allowed couples this selector is not randomized; in case of tie breaks the first one is returned

def selectMin [R] (r: Iterable[R], f: (R) ⇒ Int, st: (R) ⇒ Boolean): R

return an element r that is allowed: st(r) is true, and minimizing f(r) among the allowed couples this selector is randomized; in case of tie breaks the returned one is chosen randomly

def selectMin2 [R, S] (r: Iterable[R], s: Iterable[S], f: (R, S) ⇒ Int, st: (R, S) ⇒ Boolean): (R, S)

return a couple (r,s) that is allowed: st(r,s) is true, and minimizing f(r,s) among the allowed couples this selector is randomized; in case of tie breaks the returned one is chosen randomly

def selectMinNR [R] (r: Iterable[R], f: (R) ⇒ Int, st: (R) ⇒ Boolean): R

return an element r that is allowed: st(r) is true, and minimizing f(r) among the allowed couples this selector is not randomized; in case of tie breaks the first one is returned

def selectMinNR2 [R, S] (r: Iterable[R], s: Iterable[S], f: (R, S) ⇒ Int, st: (R, S) ⇒ Boolean): (R, S)

return a couple (r,s) that is allowed: st(r,s) is true, and minimizing f(r,s) among the allowed couples this selector is not randomized; in case of tie breaks the first one is returned

def self : Component

def setRandomized (Randomized: Boolean): Unit

def showing : Boolean

def size : Dimension

def solve (): Unit

def start (): Unit

def startSolverInThread (): Unit

def stop (): Unit

def subscribe (listener: Reaction): Unit

def synchronized [T0] (arg0: ⇒ T0): T0

def toString (): String

def toolkit : Toolkit

def unsubscribe (listener: Reaction): Unit

def visible : Boolean

def visible_= (b: Boolean): Unit

def wait (): Unit

def wait (arg0: Long, arg1: Int): Unit

def wait (arg0: Long): Unit

def size_= (dim: Dimension): Unit