Adds more files from Silverstone

Author: apblack

fallingApples/appleAnimation.grace

@@ -0,0 +1,58 @@
+import "graphix" as g
+import "random" as random
+
+// Create the graphics stage
+var graphics := g.create(200,400)
+
+def trunk = graphics.addRectangle.at(110@75).setSize(40@325).colored "SaddleBrown".filled(true).draw
+def leaves = graphics.addEllipse.at(5@30).setSize(250@140).colored "DarkGreen".filled(true).draw
+def apple = graphics.addCircle.at(50@70).setRadius 10 .colored "YellowGreen".filled(true).draw
+
+trunk.onClickDo { apple.drawAt(50@70) }
+var applePath
+
+apple.onClick := { 
+        applePath := fallPath
+        graphics.tickEvent(fall, 20)
+}
+method fallPath {
+    def duration = 500
+    def path = list []
+    def gravity = (random.between (-0.3) and 0.3)@2
+    def damping = 0.6
+    var initial := apple.location
+    def ground = initial.x@390
+    var tick := 0
+    var p := initial
+    while { p.y < ground.y } do {
+        // the fall from rest to the ground
+        // uses s = ut + (a.t^2)/2
+        tick := tick + 1
+        p := initial + (gravity * tick * tick / 2)
+        path.addLast(p)
+    }
+    var v := gravity * tick
+    repeat 10 times {
+        def u = - (v * damping)
+        v := u
+        tick := 0
+        do {
+            // the bounce:  
+            // uses s = ut + (a.t^2)/2 and v = u + at
+            tick := tick + 1
+            p := ground + (u * tick) + (gravity * tick * tick / 2)
+            v := u + (gravity * tick)
+            path.addLast(p)
+        } while { p.y < ground.y }
+    }
+    path
+}
+
+
+def fall = {
+    if (applePath.isEmpty) then { 
+        graphics.clearTicker
+    } else {
+        apple.drawAt(applePath.removeFirst)
+    }
+}

nameResolutionExample.grace

@@ -0,0 +1,20 @@
+method foo { print "outer" }
+
+class app {
+  method barf { foo }
+}
+
+class bar {
+  inherit app
+  method foo { print "bar" }
+}
+
+class baz {
+  inherit bar
+  method barf { foo }   // ambigous: self.foo or outer.foo?
+}
+
+
+app.barf  //prints "outer"
+bar.barf  //prints "outer"
+baz.barf  //prints "bar" or "outer", depending on the resolution of foo at line 14

sieveOfEratosthenes/primes-procedural.grace

@@ -0,0 +1,36 @@
+var sieve  //  sieve.at(i) represents the primeness of (2*i) + 1
+var limit 
+
+method initialize(maxPrime) {
+    limit := maxPrime
+    sieve := (1..((limit-1)/2).truncated).map { each -> true }.asList   
+}
+method markNot(n) {
+    // mark the fact that n is not a prime
+    sieve.at((n-1)/2) put(false)
+}
+method next(n) {
+    def start = (n-1)/2
+    ((start+1)..limit).do { candidate ->
+        if (sieve.at(candidate)) then { return (2*candidate) + 1 }
+    }
+}
+
+method print {
+    sieve.keysAndValuesDo { n, b -> 
+        if (b) then { prelude.print((2*n) + 1) } 
+    }
+}
+
+method runSieve {
+    var currentPrime := 3
+    var ix
+    do {
+        ix := currentPrime * 2
+        while {ix ≤ limit} do {
+            self.markNot(ix)
+            ix := ix + currentPrime
+        }
+        currentPrime := self.next(currentPrime)
+    } while { (currentPrime * currentPrime) ≤ limit }
+}

sieveOfEratosthenes/primes-withTypes.grace

@@ -0,0 +1,36 @@
+var sieve:List⟦Boolean⟧  //  sieve.at(i) represents the primeness of (2*i) + 1
+var limit:Number
+
+method initialize(maxPrime:Number) -> Done {
+    limit := maxPrime
+    sieve := (1..((limit-1)/2).truncated).map { each:Number -> true }.asList   
+}
+method markNot(n:Number) -> Done {
+    // mark the fact that n is not a prime
+    sieve.at((n-1)/2) put(false)
+}
+method next(n:Number) -> Number {
+    def start = (n-1)/2
+    ((start+1)..limit).do { candidate ->
+        if (sieve.at(candidate)) then { return (2*candidate) + 1 }
+    }
+}
+
+method print -> Done {
+    sieve.keysAndValuesDo { n, b -> 
+        if (b) then { prelude.print((2*n) + 1) } 
+    }
+}
+
+method runSieve -> Done {
+    var currentPrime:Number := 3
+    var ix:Number
+    _prelude.do {
+        ix := currentPrime * 2
+        while {ix ≤ limit} do {
+            self.markNot(ix)
+            ix := ix + currentPrime
+        }
+        currentPrime := self.next(currentPrime)
+    } while { (currentPrime * currentPrime) ≤ limit }
+}

sieveOfEratosthenes/runSieve.grace

@@ -0,0 +1,5 @@
+import "primes-withTypes" as primes
+primes.initialize(1000)
+primes.runSieve
+primes.print
+