Add tasks for all the new languages

Task/Fractal-tree/Lingo/fractal-tree-1.lingo

@@ -0,0 +1,27 @@
+----------------------------------------
+-- Creates an image of a fractal tree
+-- @param {integer} width
+-- @param {integer} height
+-- @param {integer} fractalDepth
+-- @param {integer|float} initSize
+-- @param {float} spreadAngle
+-- @param {float} [scaleFactor=1.0]
+-- @return {image}
+----------------------------------------
+on fractalTree (width, height, fractalDepth, initSize, spreadAngle, scaleFactor)
+  if voidP(scaleFactor) then scaleFactor = 1.0
+  img = image(width, height, 24)
+  img.fill(img.rect, rgb(0,0,0))
+  _drawTree(img, width/2, height, -PI/2, fractalDepth, initSize, spreadAngle, scaleFactor)
+  return img
+end
+
+on _drawTree (img, x1, y1, angle, depth, size, spreadAngle, scaleFactor)
+  if (depth) then
+    x2 = x1 + cos(angle)*depth*size
+    y2 = y1 + sin(angle)*depth*size
+    img.draw(x1, y1, x2, y2, [#color:rgb(255,255,255)])
+    _drawTree(img, x2, y2, angle-spreadAngle, depth-1, size*ScaleFactor, spreadAngle, scaleFactor)
+    _drawTree(img, x2, y2, angle+spreadAngle, depth-1, size*ScaleFactor, spreadAngle, scaleFactor)
+  end if
+end

Task/Fractal-tree/Lingo/fractal-tree-2.lingo

@@ -0,0 +1,5 @@
+fractalDepth = 10
+initSize = 7.0
+spreadAngle = 35*PI/180
+scaleFactor = 0.95
+img = fractalTree(480, 380, fractalDepth, initSize, spreadAngle, scaleFactor)

Task/Fractal-tree/Phix/fractal-tree.phix

@@ -0,0 +1,57 @@
+include ..\pGUI\pGUI.e
+
+Ihandle dlg, canvas
+cdCanvas cddbuffer, cdcanvas
+
+procedure drawTree(integer level, atom angle, atom len, integer x, integer y)
+integer xn = x + floor(len*cos(angle))
+integer yn = y + floor(len*sin(angle))
+integer red = 255-level*8
+integer grn = level*12+100
+    cdCanvasSetForeground(cddbuffer, red*#10000 + grn*#100)
+    cdCanvasLineWidth(cddbuffer,floor(5-level/3))
+    cdCanvasLine(cddbuffer, x, 480-y, xn, 480-yn)
+    if level<12 then
+        drawTree(level+1, angle-0.4, len*0.8, xn, yn)   --left
+        drawTree(level+1, angle+0.1, len*0.8, xn, yn)   --right
+    end if
+end procedure
+
+function redraw_cb(Ihandle /*ih*/, integer /*posx*/, integer /*posy*/)
+    cdCanvasActivate(cddbuffer)
+    cdCanvasClear(cddbuffer)
+    drawTree(0, -PI/2.0, 80.0, 360, 460)
+    cdCanvasFlush(cddbuffer)
+    return IUP_DEFAULT
+end function
+
+function map_cb(Ihandle ih)
+    cdcanvas = cdCreateCanvas(CD_IUP, ih)
+    cddbuffer = cdCreateCanvas(CD_DBUFFER, cdcanvas)
+    cdCanvasSetBackground(cddbuffer, CD_PARCHMENT)
+    return IUP_DEFAULT
+end function
+
+function esc_close(Ihandle /*ih*/, atom c)
+    if c=K_ESC then return IUP_CLOSE end if
+    return IUP_CONTINUE
+end function
+
+procedure main()
+    IupOpen("..\\pGUI\\")
+
+    canvas = IupCanvas(NULL)
+    IupSetAttribute(canvas, "RASTERSIZE", "640x480")
+    IupSetCallback(canvas, "MAP_CB", Icallback("map_cb"))
+    IupSetCallback(canvas, "ACTION", Icallback("redraw_cb"))
+
+    dlg = IupDialog(canvas,"RESIZE=NO")
+    IupSetAttribute(dlg, "TITLE", "Fractal Tree")
+    IupSetCallback(dlg, "K_ANY",     Icallback("esc_close"))
+
+    IupShow(dlg)
+    IupMainLoop()
+    IupClose()
+end procedure
+
+main()

Task/Fractal-tree/Ring/fractal-tree.ring

@@ -0,0 +1,50 @@
+load "guilib.ring"
+
+new qapp
+        {
+        win1 = new qwidget() {
+               setwindowtitle("drawing using qpainter")
+               setgeometry(100,100,500,500)
+               label1 = new qlabel(win1) {
+                        setgeometry(10,10,400,400)
+                        settext("")
+               }
+               draw()
+               show()
+         }
+         exec()
+         }
+
+func draw
+     p1 = new qpicture()
+             color = new qcolor() {
+             setrgb(0,0,255,255)
+        }
+        pen = new qpen() {
+              setcolor(color)
+              setwidth(1)
+        }
+        new qpainter() {
+            begin(p1)
+            setpen(pen)
+
+        sizex = 400
+        sizey = 200
+        depth = 10
+
+        tree(self, sizex, 0, sizey/2, 90, depth)
+
+        endpaint()
+        }
+        label1 { setpicture(p1) show() }
+
+        func tree myObj, x1, y1, size, angle, depth
+             myObj{
+             scale = 0.76
+             spread = 25
+             x2 = x1 + size * cos(angle)
+             y2 = y1 + size * sin(angle)
+             drawline(x1, y1, x2, y2)
+             if depth > 0
+             tree(self, x2, y2, size * scale, angle - spread, depth - 1)
+             tree(self, x2, y2, size * scale, angle + spread, depth - 1) ok}

Task/Fractal-tree/Sidef/fractal-tree.sidef

@@ -0,0 +1,23 @@
+func tree(img, x, y, scale=6/10, len=400, angle=270) {
+
+    len < 1 && return()
+
+    img.moveTo(x, y)
+    img.angle(angle)
+    img.line(len)
+
+    var (x1, y1) = img.curPos
+    tree(img, x1, y1, scale, len*scale, angle+35)
+    tree(img, x1, y1, scale, len*scale, angle-35)
+}
+
+require('GD::Simple')
+
+var (width=1000, height=1000)
+var img = %s|GD::Simple|.new(width, height)
+img.fgcolor('black')
+img.penSize(1, 1)
+
+tree(img, width/2, height)
+
+File('tree.png').write(img.png, :raw)

Task/Fractal-tree/Swift/fractal-tree.swift

@@ -0,0 +1,57 @@
+import UIKit
+
+extension CGFloat {
+  func degrees_to_radians() -> CGFloat {
+    return CGFloat(M_PI) * self / 180.0
+  }
+}
+
+extension Double {
+  func degrees_to_radians() -> Double {
+    return Double(M_PI) * self / 180.0
+  }
+
+}
+
+
+class Tree: UIView {
+
+
+  func drawTree(x1: CGFloat, y1: CGFloat, angle: CGFloat, depth:Int){
+    if depth == 0 {
+      return
+    }
+    let ang = angle.degrees_to_radians()
+    let x2:CGFloat = x1 + ( cos(ang) as CGFloat) * CGFloat(depth) * (self.frame.width / 60)
+    let y2:CGFloat = y1 + ( sin(ang) as CGFloat) * CGFloat(depth) * (self.frame.width / 60)
+
+    let line = drawLine(x1, y1: y1, x2: x2, y2: y2)
+
+    line.stroke()
+    drawTree(x2, y1: y2, angle: angle - 20, depth: depth - 1)
+    drawTree(x2, y1: y2, angle: angle + 20, depth: depth - 1)
+  }
+
+  func drawLine(x1:CGFloat, y1:CGFloat, x2:CGFloat, y2:CGFloat) -> UIBezierPath
+  {
+
+    let path = UIBezierPath()
+    path.moveToPoint(CGPoint(x: x1,y: y1))
+    path.addLineToPoint(CGPoint(x: x2,y: y2))
+    path.lineWidth = 1
+    return path
+  }
+
+  override func drawRect(rect: CGRect) {
+
+    let color = UIColor(red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)
+    color.set()
+    drawTree(self.frame.width / 2 , y1: self.frame.height * 0.8, angle: -90 , depth: 9 )
+  }
+
+
+}
+
+
+let tree = Tree(frame: CGRectMake(0, 0, 300, 300))
+tree

Task/Fractal-tree/TypeScript/fractal-tree.type

@@ -0,0 +1,35 @@
+// Set up canvas for drawing
+var canvas: HTMLCanvasElement = document.createElement('canvas')
+canvas.width = 600
+canvas.height = 500
+document.body.appendChild(canvas)
+var ctx: CanvasRenderingContext2D = canvas.getContext('2d')
+ctx.fillStyle = '#000'
+ctx.lineWidth = 1
+
+// constants
+const degToRad: number = Math.PI / 180.0
+const totalDepth: number = 9
+
+/** Helper function that draws a line on the canvas */
+function drawLine(x1: number, y1: number, x2: number, y2: number): void {
+    ctx.moveTo(x1, y1)
+    ctx.lineTo(x2, y2)
+}
+
+/** Draws a branch at the given point and angle and then calls itself twice */
+function drawTree(x1: number, y1: number, angle: number, depth: number): void {
+    if (depth !== 0) {
+        let x2: number = x1 + (Math.cos(angle * degToRad) * depth * 10.0)
+        let y2: number = y1 + (Math.sin(angle * degToRad) * depth * 10.0)
+        drawLine(x1, y1, x2, y2)
+        drawTree(x2, y2, angle - 20, depth - 1)
+        drawTree(x2, y2, angle + 20, depth - 1)
+    }
+}
+
+// actual drawing of tree
+ctx.beginPath()
+drawTree(300, 500, -90, totalDepth)
+ctx.closePath()
+ctx.stroke()

Task/Fractal-tree/jq/fractal-tree.jq

@@ -0,0 +1,38 @@
+# width and height define the outer dimensions;
+# len defines the trunk size;
+# scale defines the branch length relative to the trunk;
+def main(width; height; len; scale):
+
+  def PI: (1|atan)*4;
+
+  def precision(n):
+    def pow(k): . as $in | reduce range(0;k) as $i (1; .*$in);
+    if . < 0 then - (-. | precision(n))
+    else
+      (10|pow(n)) as $power
+    | (. * 10 * $power) | floor as $x | ($x % 10) as $r
+    | ((if $r < 5 then $x else $x + 5 end) / 10 | floor) / $power
+    end;
+
+  def p2: precision(2);
+
+  def tree(x; y; len; angle):
+    if len < 1 then empty
+    else
+      (x + len * (angle|cos)) as $x2
+    | (y + len * (angle|sin)) as $y2
+    | (if len < 10 then 1 else 2 end) as $swidth
+    | (if len < 10 then "blue" else "black" end) as $stroke
+    | "<line x1='\(x|p2)' y1='\(y|p2)' x2='\($x2|p2)' y2='\($y2|p2)' style='stroke:\($stroke); stroke-width:\($swidth)'/>",
+      tree($x2; $y2; len * scale; angle + PI / 5),
+      tree($x2; $y2; len * scale; angle - PI / 5)
+    end
+  ;
+
+  "<svg width='100%' height='100%' version='1.1'
+        xmlns='http://www.w3.org/2000/svg'>",
+        tree(width / 2; height; len; 3 * PI / 2),
+  "</svg>"
+;
+
+main(1000; 1000; 400; 6/10)