extensions [table matrix]

globals [any-change? no-change-for end-tick dom-matrix init-pop-size num-patches num-empty-env
         col-thresh trace? num-deaths num-starve num-eat num-born cumm-num-species new-species-prob
         num-deaths-disp num-starve-disp num-eat-disp num-born-disp num-migrate num-migrate-disp
         max-size dom-floor num-extinctions time-per-tick num-die-old num-die-old-disp bit-mutate-prob
         num-ticks-with-non-zero-pop survival-threshold col-incr dom-matrix-list species-col-list species-num-list dv-vals-list
         filename species-col species-num dv-vals pi-t pi-d F-st pi-env F-env F-denv num-species l0 l1 l2+ patch-set-list list-patch-chars
         analysis-phase? sample-size death-threshold num-die-rand
         s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 s12 s13 s14 s15 s16 pi1 pi2 pi3 pi4 pi5 pi6 pi7 pi8 pi9 pi10 pi11 pi12 pi13 pi14 pi15 pi16
         ]

turtles-own [gene energy level age] 
patches-own [chars resource]

to setup
  clear-all
  ifelse (strip-spaces title) = "" [set filename "iEMS Model"] [set filename strip-spaces title]
;;  set filename (word filename "-" (substring date-and-time 16 length date-and-time) "-" behaviorspace-run-number)
  ifelse initial-species-variety = 0
    [set init-pop-size 1]
    [set init-pop-size (2 / 3) * efficiency * food-rate / life-tax]
  set num-patches (max-pxcor + 1) * (max-pycor + 1)
  set survival-threshold 2 * food-rate / (life-tax * num-patches)
  set death-threshold 0
  set col-incr 30
  set num-empty-env gene-size - num-env-chars
  set col-thresh 20
  set max-size 0.25
  set sample-size 10000
  set new-species-prob init-new-species-prob
  set trace? false
  set analysis-phase? false
  set dom-floor 0.25
  set num-ticks-with-non-zero-pop max (list 200 max-age (2 * init-energy / life-tax))
  set cumm-num-species 0
  set species-col table:make
  set species-num table:make
  set dv-vals table:make
  clear-save-lists

  set dom-matrix matrix:from-row-list n-values gene-size [n-values gene-size [rand-val]]
  if anti-sym-mat? [set dom-matrix a-sym dom-matrix]
  
  set list-patch-chars []
  let n 0
  ask patches [
    set resource 0
    set chars sentence n-values num-env-chars [rand-bin] n-values num-empty-env [0]
    if not member? chars list-patch-chars [set list-patch-chars fput chars list-patch-chars]
    set pcolor (list (col-thresh * (1 + first chars)) (col-thresh * (1 + second chars)) (col-thresh * (1 + third chars)))
  ]
  set patch-set-list map [patches with [chars = ?]] list-patch-chars
  
  let temp-gene n-values gene-size [rand-bin]
  create-turtles init-pop-size [
    set age 0 + random (max-age / 3)
    set energy init-energy + random-normal 0 (init-energy / 3)
    ifelse initial-species-variety = 1
      [set gene n-values gene-size [rand-bin]]
      [set gene temp-gene]
    ifelse table:has-key? species-num gene [
      table:put species-num gene 1 + table:get species-num gene
      set color table:get species-col gene
    ] [
      set cumm-num-species cumm-num-species + 1 
      set color rand-col
      table:put species-col gene color
      table:put species-num gene 1
    ]
    setxy random (max-pxcor + 1) random (max-pycor + 1)
    set shape "star"
    set size 0.1
    set level 0
    show-turtle
    place
  ]
  
  reset-ticks
end

to place
  set xcor [pxcor] of patch-here + random-float 0.9 - 0.45
  set ycor [pycor] of patch-here + random-float 0.9 - 0.45
end

to-report a-sym [mat]
  let m2 matrix:plus mat matrix:transpose mat
  report m2
end

to-report rand-val
;;  report (random-float 2) - 1
  report random-normal 0 0.3333
end

to-report rand-bin
  report random 2
end

to-report hamming-dist [vec1 vec2]
  report sum (map [ifelse-value (?1 = ?2) [0] [1]] vec1 vec2)
end

to-report name
  report (word self)
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to go
  reset-timer
  ;; if time is done stop simulation
  if max-time > 0 and ticks  >= max-time [
      calc-stats 
      end-analysis
      stop
    ]

  set end-tick ticks
  set any-change? false
  if new-species-prob > 0 [
    if count turtles > 0 
      [set num-ticks-with-non-zero-pop num-ticks-with-non-zero-pop + 1]
    if num-ticks-with-non-zero-pop > survival-threshold [set new-species-prob 0]
  ]
  
  ;; distribute resources to patches
  ask patches [set resource resource + food-rate / num-patches]
  

  set num-starve 0
  set num-die-old 0
  set num-die-rand 0
  ;; life tax, aging and death
  ask turtles [
    set energy energy - life-tax
    set age age + 1
    if energy < death-threshold [set num-starve num-starve + 1 death]
    if max-age > 0 and age > max-age [set num-die-old num-die-old + 1 death]
    if prob rand-death-prob [set num-die-rand num-die-rand + 1 death]
  ]
  set num-die-old-disp num-die-old
  set num-starve-disp num-starve
  
  ;; new entrants from outside
  if prob new-species-prob or (initial-species-variety = 0 and count turtles = 0) [
    create-turtles 1 [
      set age 0
      set energy init-energy + random-normal 0 (init-energy / 4)
      set gene n-values gene-size [rand-bin]
      ifelse table:has-key? species-num gene [
        table:put species-num gene 1 + table:get species-num gene
        set color table:get species-col gene
      ] [
        set cumm-num-species cumm-num-species + 1 
        set color rand-col
        table:put species-col gene color
        table:put species-num gene 1
      ]
      setxy random (max-pxcor + 1) random (max-pycor + 1)
      set shape "star"
      set size 0.1
      set level 0
      show-turtle
      place
    ]
  ]
  
  ;; extracting energy from the patch
  ;; at the moment the energy is shared by any > dom-floor proportionately
  ask patches [
    if not any? turtles-here [stop]
    let tl sort turtles-here
    let nt (length tl) - 1
    let rl []
    ifelse neutral? 
      [set rl map [0.01] tl]
      [set rl map [? - dom-floor] map [max list dom-floor dv ([gene] of ?) chars] tl]
    let sumrl sum rl
    if sumrl = 0 [stop]
    let lf resource / sumrl
    let i 0
    foreach seq 0 nt 1 [
      set i item ? rl
      if i > 0 [
        ask item ? tl [set energy energy + efficiency * lf * i]
        set resource resource - lf * i
      ]
    ]
  ]
  
  ;; predation
  set num-eat 0
  ask turtles [
    foreach safeSubList (shuffle sort other turtles-here) 0 eating-tries [
      if dom? gene [gene] of ? [
        set level 1 + [level] of ?
        set energy energy + efficiency * [energy] of ?
        ask ? [death]
        set num-eat num-eat + 1
        set shape "circle"
        set size min list max-size size + 0.05
      ]
    ]
  ]
  set num-eat-disp num-eat
  
  ;; reduce all stores to max-store if this is > 0
  if max-store > 0 [
    ask turtles [
      set energy min list energy max-store
    ]
  ]
  
  ;; births
  set num-born 0
  ask turtles [
    if energy >= reproduce-level [
      hatch 1 [
        let col [0 0 0]
        set age 0
        set energy init-energy
        set size 0.1
        set shape "star"
        set level 0
        if prob mut-prob [
          set gene mutate gene
          ifelse table:has-key? species-num gene [
            set color table:get species-col gene
          ] [
            set cumm-num-species cumm-num-species + 1 
            set color shade color
            table:put species-col gene color
            table:put species-num gene 0
          ]
        ]
        table:put species-num gene 1 + table:get species-num gene
        place
      ]
      set num-born num-born + 1
      set energy energy - init-energy
    ]
  ]
  set num-born-disp num-born
  
  ;; migrations
  set num-migrate 0
  ifelse migrate-near? [
    ask turtles [if prob migration-prob [move-near]]
  ] [
    ask turtles [
      if prob migration-prob [
        setxy random (max-pxcor + 1) random (max-pycor + 1)
        place
        set num-migrate num-migrate + 1
      ]
    ]
  ]
  set num-migrate-disp num-migrate
  
  set num-species table:length species-num
  set l0 safeDiv count turtles with [level = 0] count turtles
  set l1 safeDiv count turtles with [level = 1] count turtles
  set l2+ safeDiv count turtles with [level > 1] count turtles
  
  set time-per-tick timer
  tick
end

to death
  let num-of-this (table:get species-num gene) - 1
  table:put species-num gene num-of-this
  if num-of-this < 1 [
    table:remove species-col gene
    table:remove species-num gene
  ]
  die
end

to-report dv [g1 g2]
  let op 0
    ifelse table:has-key? dv-vals list g1 g2
      [set op table:get dv-vals list g1 g2]
      [set op calc-dv g1 g2
       table:put dv-vals list g1 g2 op]
  report op 
end

to clear-dv-cache
  table:clear dv-vals
end

to-report calc-dv [g1 g2]
;;  if affected-char > 0 [
  if affected-char > 0 [
    set g1 replace-item (affected-char - 1) g1 0
    set g2 replace-item (affected-char - 1) g2 0
  ]
  let op 0
  let i 0
  foreach (seq 0 (gene-size - 1) 1) [
    set i ?
    if (item i g1) != 0 [
      foreach seq 1 (gene-size - 1) 1 [
        set op op + (item ? g2) * (matrix:get dom-matrix i ?)
      ]
    ]
  ]
  report op
end

to move-near
  let ns neighbors
  if not any? ns [stop]
  let next-patch one-of ns
  setxy [pxcor] of next-patch [pycor] of next-patch
  place
  set num-migrate num-migrate + 1
end

to-report rand-plus-minus
  report (2 * random 2) - 1
end

to-report dom? [g1 g2]
  if not allow-cannibals? and g1 = g2 [report false]
  report dv g1 g2 > dom-floor
end

to-report sel-pos [pl vl]
  if empty? pl [report []]
  ifelse first pl > 0 
    [report fput first vl (sel-pos but-first pl but-first vl)]
    [report sel-pos but-first pl but-first vl]
end

to-report shade [cl]
  report (list chc first cl chc second cl chc last cl)
end

to-report rand-col
  report (list rand-rbg-val rand-rbg-val rand-rbg-val)
end

to-report rand-rbg-val
  report col-thresh + random-float (255 - col-thresh)
end
  
to-report chc [v]
  report min list 255 max list col-thresh ch-val v
end

to-report ch-val [v]
  if v >= 255 [report v - col-incr - random col-incr]
  if v <= col-thresh [report v + col-incr + random col-incr]
  ifelse 0 = random 2
    [report v + col-incr + random col-incr]
    [report v - col-incr - random col-incr]
end

to-report mutate [g]
;;  report flip-bit random gene-size g
  let op []
  repeat length g [
    ifelse prob mut-prob 
      [set op fput (1 - first g) op]
      [set op fput first g op]
    set g but-first g
  ]
  report reverse op
end

to-report flip-bit [p g]
  report replace-item p g (1 - item p g)
end

to calc-stats
  set pi-t 0
  set pi-t safeDiv pi-t sample-size
  set pi-d 0
  set F-st 0
  set pi-env 0
  set F-env 0
  let ot nobody
  let my-gene []
  let ps nobody
  let p nobody
  let p1 nobody
  let p2 nobody
  if any? turtles [
    repeat sample-size [
      ask one-of turtles [
        set my-gene gene
        if any? other turtles
          [ask one-of other turtles  [set pi-t pi-t + hamming-dist my-gene gene]]
      ]
    ]
    repeat sample-size [
      ask one-of turtles [
        set my-gene gene
        if any? other turtles-here 
           [ask one-of other turtles-here [set pi-d pi-d + hamming-dist my-gene gene]]
      ]
    ]
    set ps map [turtles-from ?] patch-set-list
    repeat sample-size [
       set p random-member ps
       if any? p [
         set p1 one-of p
         ask p1 [set p2 one-of other (turtle-set ps)]
         if p2 != nobody [
           set pi-env pi-env + hamming-dist [gene] of p1 [gene] of p2
         ]
       ]
    ]
    set pi-d safeDiv pi-d sample-size  
    set pi-t safeDiv pi-t sample-size
    set pi-env safeDiv pi-env sample-size
    set F-st safeDiv (pi-t - pi-d) pi-t
    set F-env safeDiv (pi-t - pi-env) pi-t
    set F-denv safeDiv (pi-env - pi-d) pi-env
  ]
end

to-report turtles-from [ps]
  report turtles with [member? patch-here ps]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
to a-a-SAVE-LOAD end

to save-world
  set dom-matrix-list matrix:to-row-list dom-matrix
  set species-col-list table:to-list species-col
  set species-num-list table:to-list species-num
  export-world (word title "-state.csv")
end

to load-world
  import-world (word title "-state.csv")
  set dom-matrix matrix:from-row-list dom-matrix-list
  set species-col table:from-list species-col-list
  set species-num table:from-list species-num-list
  set dv-vals-list []
  table:clear dv-vals
  set analysis-phase? true
end

to clear-save-lists
  set dom-matrix-list []
  set species-col-list [] 
  set species-num-list []
  set dv-vals-list []
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
to a-a-ANALYSIS end

to start-analysis
  set analysis-phase? true
  clear-dv-cache
  random-seed new-seed
end

to end-analysis
  calc-niche-stats
end

to calc-niche-stats
  let p 0 let ps nobody let as nobody let char-num 0
  let list-patch-nums map [num-from-binvec ? num-env-chars] list-patch-chars

  if num-env-chars < 1 [stop]
    set char-num 1
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s1 calc-ns as
  set pi1 calc-pi as
  ]
    set char-num 2
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s2 calc-ns as
  set pi2 calc-pi as
  ]
  if num-env-chars < 2 [stop]
    set char-num 3
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s3 calc-ns as
  set pi3 calc-pi as
  ]
    set char-num 4
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s4 calc-ns as
  set pi4 calc-pi as
  ]
    if num-env-chars < 3 [stop]
    set char-num 5
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s5 calc-ns as
  set pi5 calc-pi as
  ]
    set char-num 6
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s6 calc-ns as
  set pi6 calc-pi as
  ]
    set char-num 7
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s7 calc-ns as
  set pi7 calc-pi as
  ]
    set char-num 8
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s8 calc-ns as
  set pi8 calc-pi as
  ]
  if num-env-chars < 4 [stop]
    set char-num 9
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s9 calc-ns as
  set pi9 calc-pi as
  ]
    set char-num 10
  set p position (char-num - 1) list-patch-nums 
  if p != false [
    set ps item p patch-set-list
    set as turtles-from ps
    set s10 calc-ns as
    set pi10 calc-pi as
  ]
    set char-num 11
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s11 calc-ns as
  set pi11 calc-pi as
  ]
    set char-num 12
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s12 calc-ns as
  set pi12 calc-pi as
  ]
    set char-num 13
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s13 calc-ns as
  set pi13 calc-pi as
  ]
    set char-num 14
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s14 calc-ns as
  set pi14 calc-pi as
  ]
      set char-num 15
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s15 calc-ns as
  set pi15 calc-pi as
  ]
    set char-num 16
  set p position (char-num - 1) list-patch-nums 
  if p != false [
  set ps item p patch-set-list
  set as turtles-from ps
  set s16 calc-ns as
  set pi16 calc-pi as
  ]
end

to-report calc-pi [ts]
  if count ts <= 1 [report 0]
  let op 0 let t1 nobody let t2 nobody
  repeat sample-size [
    set t1 one-of ts
    ask t1 [set t2 one-of other ts]
    set op op + hamming-dist [gene] of t1 [gene] of t2
  ]
  report op / sample-size
end

to-report calc-ns [ts]
  report length remove-duplicates [gene] of ts
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
to a-a-GEN-UTILS end

to-report sign [num]
  if num = 0 [report 0]
  ifelse num > 0
    [report 1]
    [report -1]
end

to-report num-from-binvec [binvec numplaces]
  let op 0
  foreach seq 0 (numplaces - 1) 1 [
    set op op + (2 ^ ?) * item ? binvec
  ]
  report op
end

to-report second [l]
  report first but-first l
end

to-report num-links
  report count my-links
end

to-report set-pos [pos lis]
  report replace-item pos lis 1
end

to-report clear-pos [pos lis]
  report replace-item pos lis 0
end

to-report safe-item [pos lis]
  if pos > (length lis - 1) [report 0]
  report item pos lis
end

to-report remove-list [remlis lis]
  let opl lis
  foreach remlis [
    set opl remove ? lis
  ]
  report opl
end

to-report n-colours [n]
  ;; produces a list of n random visible colurs (not too near black)
  report n-values n [(list (10 + random 245) (10 + random 245) (10 + random 245))]
end

to-report poss-of-len [dim]
  if dim <= 0 [report [[]]]
  let poss-minus1 poss-of-len (dim - 1)
  report sentence (map [fput 0 ?] poss-minus1) (map [fput 1 ?] poss-minus1)
end

to pause
  if not user-yes-or-no? (word "Continue?") [error "User halted simulation!!"]
end

to-report showpause [inp]
  if not user-yes-or-no? (word "Value is: " inp " -- Continue?") [error "User halted simulation!!"]
  report inp
end

to ipat [p1 p2]
  inspect patch p1 p2
end

to ith
  ask turtles-here [inspect self]
end

to-report link-breed [p1 p2]
  let pl []
  ask p1 [set pl sort my-links]
  ask p2 [
    let p2l sort my-links
    set pl filter [member? ? p2l] pl
  ]
  if empty? pl [report "none"]
  report [breed] of (random-member pl)
end
  
to-report random-member [ls]
  report item (random length ls) ls
end

to-report prob [p]
  report random-float 1 < p
end

to-report subtract-list [lis1 lis2]
  report filter [not member? ? lis2] lis1
end

to-report safeSubList [lis srt en]
  let len length lis
  if en < 1 or srt > len [report []]
  report subList lis max list 0 srt min list en len
end

to-report safe-n-of [nm lis]
  if is-list? lis [if length lis >= nm [report n-of nm lis]]
  if is-agentset? lis [if count lis >= nm [report n-of nm lis]]
  report lis
end

to-report safe-one-of [lis]
  report safe-n-of 1 lis
end

to-report flatten-once [lis]
  let op-list []
  foreach lis [
    foreach ? [set op-list fput ? op-list]
  ]
  report op-list
end

to-report minList [lis1 lis2]
  report (map [min list ?1 ?2] lis1 lis2)
end

to-report maxList [lis1 lis2]
  report (map [max list ?1 ?2] lis1 lis2)
end

to-report sumList [lis1 lis2]
  report (map [?1 + ?2] lis1 lis2)
end

to-report sdList [sqLis sumLis numLis] 
  report (map [sqrt max (list 0 ((?1 / numLis) - ((?2 / numLis) ^ 2)))] sqLis sumLis)
end

to-report fputIfNew [exLisLis newLis]
  report (map [ifelse-value (member? ?2 ?1) [?1] [fput ?2 ?1]] exLisLis newLis)
end

to-report csv-string-to-list [str]
  let lis []
  while [not empty? str] [
    set lis fput next-value str lis
    set str after-next str
  ]  
  report reverse lis
end  

to-report after-next [str]
  let pos-comma position "," str
  if pos-comma != false [report subString str (pos-comma + 1) length str]
  report ""
end  

to-report next-value [str]
  let pos-comma position "," str
  if pos-comma != false [
    report read subString str 0 pos-comma
    ]
  report read str
end

to-report read [str]
  set str strip-spaces str
  if empty? str [report nobody]
    ifelse is-string-a-number? str
      [report read-from-string str]
      [report str]
end  

to-report strip-spaces [str]
  report strip-leading-spaces strip-trailing-spaces str
end  

to-report strip-leading-spaces [str]
  if empty? str [report str]
  if first str != " " [report str]
  report strip-leading-spaces but-first str
end

to-report is-string-a-number? [str]
  if empty? str 
    [report false]
  report is-nonempty-string-a-number? str
end

to-report is-nonempty-string-a-number? [str]
  if empty? str [report true]
  let ch first str
  if ch = "." [report is-string-digits? but-first str]
  if not is-str-digit? ch [report false]
  report is-nonempty-string-a-number? but-first str
end

to-report is-string-digits? [str]
  if empty? str [report true]
  let ch first str
  if not is-str-digit? ch [report false]
  report is-string-digits? but-first str
end  
  
to-report is-str-digit? [ch]
  ifelse ch >= "0" and ch <= "9"
    [report true]
    [report false]
end

to-report strip-trailing-spaces [str]
  if empty? str [report str]
  if last str != " " [report str]
  report strip-trailing-spaces but-last str
end  

to-report insert [itm ps lis]
  report (sentence sublist lis 0 ps (list itm) sublist lis ps (length lis))
end

to-report insertAfter [itm ps lis]
  report insert itm (ps + 1) lis
end

to-report num-nodes [lis]
  report length nodes-in lis
end

to-report nodes-in [lis]
  if not is-list? lis [report (list lis)]
  let op-list []
  foreach lis [set op-list append op-list nodes-in ?]
  report op-list
end

to-report third [lis]
  report item 2 lis
end

to XXX
  let tt 1 
  set tt tt - 1
  set tt 1 / tt
end

to-report showPass [arg]
  show arg
  report arg
end

to-report posBiggest [lis]
  report position (reduce [ifelse-value (?1 >= ?2) [?1] [?2]] lis) lis 
end

to-report allPos [expr]
  let oplis [[]]
  foreach but-first (n-values (length expr) [?]) [
    let ps ?
    let posLis allPos (item ps expr)
    set opLis append (map [fput ps ?1] posLis) opLis
  ]
  report opLis
end

to-report replaceAtPos [posList baseExpr insExpr]
  if posList = [] [report insExpr]
  report replace-item (first posList) baseExpr (replaceAtPos (but-first posList) (item first posList baseExpr) insExpr)
end

to-report atPos [posList expr]
  if empty? posList [report expr]
  report atPos but-first posList item (first poslist) expr
end

to-report append [list1 list2]
  if empty? list1 [report list2]
  report fput (first list1) (append (but-first list1) list2)
end

to-report selectProbilistically [charList numList]
  report item (chooseProbilistically numList) charList
end

to-report chooseProbilistically [numList]
  report findPos (random-float 1) cummulateList scaleList numList
end

to-report chooseReverseProbilistically [numList]
  if length numList = 1 [report 0]
  report findPos (random-float 1) cummulateList reverseProbList scaleList numList
end

to-report reverseProbList [numList]
  report map [1 - ?1] numList
end

to-report cummulateList [numList]
  report cummulateListR numList 0
end

to-report cummulateListR [numList cumm]
  if empty? numList [report []]
  let newCumm cumm + first numList
  report fput newCumm cummulateListR but-first numList newCumm
end

to-report scaleList [numLis]
  if empty? numLis [report numLis]
  let sumLis sum numLis
  if sumLis = 0 [report numLis]
  report map [?1 / sumLis] numLis
end

to-report findPos [vl numList]
  report findPosR vl numList 0
end

to-report findPosR [vl numList  ps]
  if empty? numList [report ps]
  if vl <= (first numList) [report ps]
  report findPosR vl but-first numList (1 + ps)
end

to-report freqOfIn [lis allList]
  report reduce [fput (numOfIn ?2 lis) ?1 ] (fput [] allList)
end  
  
to-report freqOf [lis]
  if empty? lis [report []]
  let sort-lis sort lis
  let red-lis sort remove-duplicates lis
  let op-lis red-lis
  let num-lis []
  let cnt 0
  foreach sort-lis [
    ifelse ? = first red-lis 
      [set cnt cnt + 1]
      [set num-lis fput cnt num-lis 
       set cnt 1
       set red-lis but-first red-lis]
  ]
  set num-lis fput cnt num-lis 
  report pair-list (reverse num-lis) op-lis
;;  report pair-list reverse num-lis red-lis
  ;;  report fput (list (numOfIn first lis lis) (first lis)) (freqOf remove first lis lis)
end

to-report freqRep [lis]
  report sort-by [first ?1 > first ?2] filter [first ? > 1] freqOf lis 
end

to-report numOfIn [itm lis]
  report length (filter [itm = ?] lis)
end

to-report patchesToDist [dist]
  if dist = 0 [report self]
  let patchList []
  foreach seq (-1 * dist) dist 1 [
    let xc ?
      foreach seq (-1 * dist) dist 1 [
        set patchList fput patch-at xc ? patchList
      ]
  ]
  report patch-set patchList
end

to-report individualsToDist [dist]
  report turtles-on patchesToDist dist
end

to-report distBetween [x1 y1 x2 y2]
  report (max list abs (x1 - x2) abs (y1 - y2))
;;  report sqrt (((x1 - x2) ^ 2) + ((y1 - y2) ^ 2))
end

to-report seq [from upto stp]
  report n-values (1 + ceiling ((upto - from) / stp)) [from + ? * stp]
end

to-report safeDiv [numer denom]
  if denom = 0 and numer = 0 [report 1]
  if denom = 0 [report 0]
  report numer / denom
end  

;;to-report flip-bit [ps bitList]
;;  report replace-item ps bitList (1 - (item ps bitList))  
;;end


to showList [lis]
  foreach but-last lis [type ? type " "]
  print last lis
end


to-report is-divisor-of [num den] 
  report (0 = (num mod den))
end

to-report pair-list [lis1 lis2]
 report (map [list ?1 ?2] lis1 lis2)
end

to-report depth [lis]
  if not is-list? lis [report 0]
  if empty? lis [report 0]
  report 1 + max map [depth ?] lis
end

to-report empty-as
  report no-turtles
end

to-report exists [obj]
  if is-turtle-set? obj [report any? obj]
  report obj != nobody
end

to-report pick-at-random-from-list [lis]
  report item random length lis lis
end

to tv [str val]
  if trace? [output-print (word str "=" val)]
end

to-report normal-dist [x mn sd]
  report exp (-0.5 * ((x - mn) / sd) ^ 2) / (sd * sqrt (2 * pi))
end

to-report careful-item [ps lis str]
  let rs 0
  carefully 
    [set rs item ps lis] 
    [output-print (word "str" ": no position " ps " in: " lis)]
  report rs
end
@#$#@#$#@
GRAPHICS-WINDOW
186
10
596
441
-1
-1
50.0
1
10
1
1
1
0
1
1
1
0
7
0
7
1
1
1
ticks
30.0

BUTTON
663
381
718
414
NIL
setup
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

BUTTON
720
381
775
414
NIL
go\n
T
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

SLIDER
7
10
180
43
gene-size
gene-size
1
100
100
1
1
NIL
HORIZONTAL

BUTTON
720
416
775
449
step
go
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

SLIDER
7
45
180
78
num-env-chars
num-env-chars
0
10
3
1
1
NIL
HORIZONTAL

SLIDER
7
81
179
114
migration-prob
migration-prob
0
0.05
0.01
0.0001
1
NIL
HORIZONTAL

SLIDER
6
117
178
150
mut-prob
mut-prob
0
0.01
0.01
0.0001
1
NIL
HORIZONTAL

INPUTBOX
663
10
766
70
title
explore 8 test
1
0
String

INPUTBOX
663
75
726
135
max-time
100000
1
0
Number

SLIDER
5
156
177
189
food-rate
food-rate
0
500
500
1
1
NIL
HORIZONTAL

SLIDER
6
192
178
225
life-tax
life-tax
0
10
0.05
0.01
1
NIL
HORIZONTAL

SLIDER
6
230
178
263
init-energy
init-energy
0
10
1
.1
1
NIL
HORIZONTAL

SLIDER
5
266
177
299
efficiency
efficiency
0
1
0.9
0.01
1
NIL
HORIZONTAL

SLIDER
5
303
177
336
reproduce-level
reproduce-level
0
10
3
0.1
1
NIL
HORIZONTAL

PLOT
772
10
1001
160
Energy Distribution
Energy
Number
0.0
1.0
0.0
10.0
true
false
"set-plot-x-range 0 reproduce-level\nset-plot-pen-interval life-tax" ""
PENS
"default" 1.0 1 -16777216 true "" "histogram [energy] of turtles"

PLOT
784
319
1001
449
Population
Time
Number
0.0
10.0
0.0
10.0
true
false
"" ""
PENS
"default" 1.0 0 -16777216 true "" "if ticks > 0 [plot count turtles]"

SLIDER
6
339
178
372
eating-tries
eating-tries
0
10
3
1
1
NIL
HORIZONTAL

MONITOR
663
139
713
184
Eats
num-eat-disp
17
1
11

MONITOR
716
139
766
184
Deaths
num-starve-disp + num-eat-disp
17
1
11

MONITOR
664
187
714
232
Births
num-born-disp
17
1
11

MONITOR
717
187
767
232
Pop
count turtles
17
1
11

PLOT
773
163
999
313
Tropic Level Distribution
NIL
NIL
0.0
10.0
0.0
10.0
true
false
"" "set-plot-pen-interval 1"
PENS
"default" 1.0 1 -16777216 true "" "histogram [level] of turtles"

MONITOR
664
237
714
282
Species
num-species
0
1
11

MONITOR
717
236
767
281
Starve
num-starve-disp
17
1
11

MONITOR
650
443
710
488
secs/tick
time-per-tick
3
1
11

SLIDER
5
375
177
408
max-age
max-age
0
1000
100
10
1
NIL
HORIZONTAL

MONITOR
664
285
714
330
Old
num-die-old-disp
17
1
11

SWITCH
1
556
132
589
anti-sym-mat?
anti-sym-mat?
1
1
-1000

MONITOR
717
285
768
330
CumS
cumm-num-species
17
1
11

SWITCH
260
554
391
587
migrate-near?
migrate-near?
0
1
-1000

MONITOR
664
333
714
378
Migr
num-migrate-disp
17
1
11

BUTTON
200
553
255
586
Calc
calc-stats
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

MONITOR
199
492
256
545
NIL
pi-t
2
1
13

MONITOR
261
492
318
545
NIL
pi-d
2
1
13

MONITOR
321
491
378
544
NIL
F-st
2
1
13

MONITOR
572
493
629
546
L0
l0
3
1
13

MONITOR
634
494
691
547
L1
l1
4
1
13

MONITOR
696
494
753
547
L2+
l2+
4
1
13

SLIDER
4
449
177
482
init-new-species-prob
init-new-species-prob
0
0.01
0.01
0.0001
1
NIL
HORIZONTAL

SLIDER
3
485
176
518
initial-species-variety
initial-species-variety
0
1
0
1
1
NIL
HORIZONTAL

PLOT
757
454
1001
604
Number of Species
Time
Number
0.0
10.0
0.0
10.0
true
false
"" ""
PENS
"default" 1.0 0 -16777216 true "" "if ticks > 0 [plot num-species]"

SWITCH
1
592
257
625
stop-new-species-once-established?
stop-new-species-once-established?
0
1
-1000

SWITCH
409
591
504
624
neutral?
neutral?
1
1
-1000

SWITCH
260
591
403
624
allow-cannibals?
allow-cannibals?
1
1
-1000

BUTTON
2
629
57
662
Save
save-world
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

BUTTON
73
628
128
661
Load
load-world
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

BUTTON
133
628
188
661
Start-A
start-analysis
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

MONITOR
382
492
444
545
pi-env
pi-env
3
1
13

MONITOR
449
492
506
545
F-env
F-env
2
1
13

MONITOR
511
493
568
546
NIL
F-denv
2
1
13

BUTTON
254
629
309
662
End-A
end-analysis
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

BUTTON
192
629
249
662
Do-A
go
T
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

SLIDER
323
629
495
662
affected-char
affected-char
0
16
0
1
1
NIL
HORIZONTAL

PLOT
509
551
753
698
Log Population Types
Time
Log 10 Number
0.0
1.0
0.0
1.0
true
true
"" ""
PENS
"l0" 1.0 0 -2674135 true "" "if ticks > 1 [plot log (1 + (count turtles with [level = 0])) 10]"
"l1" 1.0 0 -955883 true "" "if ticks > 1 [plot log (1 + (count turtles with [level = 1])) 10]"
"l2" 1.0 0 -13840069 true "" "if ticks > 1 [plot log (1 + (count turtles with [level = 2])) 10]"
"l3" 1.0 0 -14835848 true "" "if ticks > 1 [plot log (1 + (count turtles with [level = 3])) 10]"
"l4" 1.0 0 -13791810 true "" "if ticks > 1 [plot log (1 + (count turtles with [level = 4])) 10]"
"l5+" 1.0 0 -13345367 true "" "if ticks > 1 [plot log (1 + (count turtles with [level > 4])) 10]"

SLIDER
4
521
176
554
rand-death-prob
rand-death-prob
0
0.05
0.0050
0.001
1
NIL
HORIZONTAL

MONITOR
717
333
773
378
Rand Die
num-die-rand
0
1
11

MONITOR
758
609
815
654
Ticks
ticks
17
1
11

SLIDER
6
410
178
443
max-store
max-store
0
100
20
1
1
NIL
HORIZONTAL

@#$#@#$#@
## SUMMARY

This is a model of different ecoologies developing with evolution.  This is an experimental model that combines elements of a meta-population model with a "McKane" style of simulated evolution (but with individuals rather than populations represented).

Each patch has a set of characteristics composed of a binary vector and a level of resources (energy) that is replenished each simulation tick.  

Each individual of a species has the same gene composed of a vector of fixed length. It also has an energy level and an age. Each iteration a life-tax is subtracted from its energy.  If its energy falls below 0 it dies.  If its energy level exceeds a set level it reproduces into the same patch (with a possible mutation) - the energy of the offspring is subtracted from the parent. If its age exceeds the maximum age it also dies (unless maximum age is set to 0).  There is a small probability of migrating to another patch (there are two settings for this - either to another random patch or only neighboring patches).

Energy is gained in one of two ways:

1. by extraction from the environment by comparing its gene against the vector of characteristics for the patch it is on.  In this case the scores of individuals that are achieve value > 0 determine the distribution of the fixed pot of energy for the patch.

2. by eating other individuals.  Each individual tries to eat a set number of random others on their patch.  The success of this is determined by comparing its gene against the gene of the other.  If the score is greater than a threshold (currently 0) then it eats the other, adsorbing a percentage of the other's energy and the other dying.

Method of "comparison" in (1) and (2) above:

During initialisate a random square matrix with dimension of the same length as a gene is generated (this can be optionally forced to be anti-symmetric).  This matrix determines the score of one gene against another gene or patch characteristic vextor.  All the entries indicated by a "1" in both are summed, the first indicating the selected columns, the second the rows.

New species arise due to a mutation occuring during propagation or the introduction of a new random species from outside.


## OUTPUTS

The world is divided into patches the background colouring indicates its characteristics.

Individuals are small stars (if never eaten another individual) or circles (getting bigger for each other they eat) if they have.  Colouring indicates species.  Position within patches is not significant and randomised.

Energy Distribnution is a histogram of the energy levels of individuals.

Tropic Level Distribution is a histogram of the trophic levels.  This is of individuals not species, so if an individual has eaten another that has eaten a 'herbivore' then it has a trophic level of at least 2.

pi-t and pi-d is (an estimate of) the average hamming distance between pairs of indiviuduals in the whole simulation and within patches respectively.

F-st is (pi-t - pi-d) / pi-t and is a measure of the amount of variety between patches.

F-st, pi-t and pi-d are only calculated at the end of simulations or when the button is pressed since it takes a while to calculate them.

L0, L1, L2+ are the number of individuals at trophic levels 0, 1 and above 1.

## INITIALISATION

Patches are initialised with a random set of characteristics depending on num-env-chars.

At the start a population of efficiency * food-rate / life-tax individuals is created with the an energy distibution of init-energy + random-normal 0 (init-energy / 4) and a genetic distribution depending on the initial-species-variety setting (see above).

There are two sensible sets of settings for this simulation:

1. With initial-species-variety=1, new-species-prob=0 -- so the initial variety ensures that some species are viable, resulting in a slow initial decline in number of species.

2. With initial-species-variety=0, new-species-prob>0 -- in this case species are introduced (McKane fashion) one by one until a viable one is discovered.  In this case the stop-new-species-once-established? might be used to stop the introduction of random species after a viable population is established.

## PARAMETERS AND SETTINGS

gene-size - the number of bits in an individual's gene 

num-env-chars - the number of (effective) bits in the characteristics of a patch (functions similar to an individual's gene)

migration-prob - the probability that any individual will move to another patch each time click

mut-prob - the probability that a newly born individual will have its gene mutated

food-rate - how much energy is put into the patches each time click (evenly divided among patches)

life-tax - how much energy subtracted from each individual each time click (dies if energy is 0 or below)

init-energy - the energy of a new born (this is subtracted from the parent at birth)

efficiency - what proportion of energy of something eaten goes to predator (or to herbivore from patch)

reproduce-level - if an individual's energy gets to this point it gives birth once (new born's energy being then ssubtracted from it)

eating-tries - each tick each individual tries to eat this number of others on the same patch, but this only happens if they dominate them via the interaction matrix

max-age - if > 0 individuals die when they reach this age in simulation ticks (otherwise no age ceiling)

max-store - if > 0 this is the upper bound on what energy individuals can accumulate (rest is lost to system)

init-new-species-prob - probability of a new individual with a random geneome being introduced each time click 

stop-new-species-once-established? - if set stops new individuals with new genomes being introduced into the simulation once a viable population is established

initial-species-variety - 0/1 - if 0 simulation starts with a single individual (if this is not successful relies on a new individual being intyroduced via init-new-species-prob), if 1 starts with a full population with random genes

rand-death-prob - the probability an individual dies each time click (apart from other reasons)

anti-sym-mat? - forces the interaction matrix generated at start to be anti-symmetric

migrate-near? - if true then individuals migrate (if they do) to a neighbouring patch if false to a random other patch

allow-cannibals? - if true individuals of the same species can eat each other, if not can only eat those of another species

neutral? - if true then all individuals on a patch get the same amount of energy from the patch regardless of their geneome (otherwise they have to dominate the patch via the interaction matrix)

max-time - if > 0 the time at which the simulation is halted

## SECOND STAGE ANALYSIS

At any point the state of the world can be saved to disk or retrieved (using the Save and Load buttons).  When this happens the filename uses that in the "title" input box. 

affected-char - if > 0 this prevents the numbered characteristic being taken into acount during dominance calculations using the interaction matrix.  In other words this characteristic is supressed in terms of its efficacy.

The the Start-A, Do-A and End-A buttons initialise, do and calculate final stats from this point (up to max-time) with the affected-char intervention in place

## OUTPUTS AND MONITORS

In current tick:

Eats - how many are eaten 
Deaths - total systematic deaths (eaten, starve, got too old)
Births - number of new individuals born due to parent reaching required energy 
Pop - number of live individuals
Species - how many distinct genomes there are in living individuals
Starve - how many died of lack of energy
Old - how many died due to reaching max-age
Migr - how many migrated to another patch
Rand Die - how many died randomly (due to rand-death-prob)
secs/tick - how long current simulation tick took to compute (in seconds)
L0 - proportion of individuals that have not eated anyone ever (herbivores)
L1 - proportion of individuals that have ever eaten a herbivore
L2 - proportion of individuals that have ever eaten a carnivore

CummS - how many distinct geneomes have been created in current simulation

Only calculated when press Calc button or at end of simulation.  All are about diversity measured as the average hamming distance between pairs of distinct individuals (estimated using random sample of 10000)

pi-t - the overall diversity
pi-d - diversity within patches
F-st - (pi-t - pi-d) / pi-t i.e. how much diversity is inter-patch
pi-env - diversity within all patches with same characteristics
F-env - (pi-t - pi-env) / pi-t how much diversity is inter-ptach-type
F-denv (pi-env - pi-d) / pi-env how much within patch diversity is due to variation between patches with same characteristics

## GRAPHS

Energy Distribution -  histogram of the energy levels of individuals
Tropic Level Distribution - a histogram of number of individuals at each tropic level
Population - graph of number of living individuals
Number of Species - graph of number of distinct geneomes in current population
Log Population Types - graph of the number of individuals at different tropic levels (on a logarithmic scale)

## RELATED MODELS

This model relates to the McKane series of models to simulation the evolution of food webs, to meta-population models and to the "Patterns of genetic variation in populations of infectious agents" paper by Isabel Gordo and Paulo RA Campos in BMC Evoilutionary Biology.

## CREDITS AND REFERENCES


Bruce Edmonds
7/11/12
@#$#@#$#@
default
true
0
Polygon -7500403 true true 150 5 40 250 150 205 260 250

airplane
true
0
Polygon -7500403 true true 150 0 135 15 120 60 120 105 15 165 15 195 120 180 135 240 105 270 120 285 150 270 180 285 210 270 165 240 180 180 285 195 285 165 180 105 180 60 165 15

arrow
true
0
Polygon -7500403 true true 150 0 0 150 105 150 105 293 195 293 195 150 300 150

box
false
0
Polygon -7500403 true true 150 285 285 225 285 75 150 135
Polygon -7500403 true true 150 135 15 75 150 15 285 75
Polygon -7500403 true true 15 75 15 225 150 285 150 135
Line -16777216 false 150 285 150 135
Line -16777216 false 150 135 15 75
Line -16777216 false 150 135 285 75

bug
true
0
Circle -7500403 true true 96 182 108
Circle -7500403 true true 110 127 80
Circle -7500403 true true 110 75 80
Line -7500403 true 150 100 80 30
Line -7500403 true 150 100 220 30

butterfly
true
0
Polygon -7500403 true true 150 165 209 199 225 225 225 255 195 270 165 255 150 240
Polygon -7500403 true true 150 165 89 198 75 225 75 255 105 270 135 255 150 240
Polygon -7500403 true true 139 148 100 105 55 90 25 90 10 105 10 135 25 180 40 195 85 194 139 163
Polygon -7500403 true true 162 150 200 105 245 90 275 90 290 105 290 135 275 180 260 195 215 195 162 165
Polygon -16777216 true false 150 255 135 225 120 150 135 120 150 105 165 120 180 150 165 225
Circle -16777216 true false 135 90 30
Line -16777216 false 150 105 195 60
Line -16777216 false 150 105 105 60

car
false
0
Polygon -7500403 true true 300 180 279 164 261 144 240 135 226 132 213 106 203 84 185 63 159 50 135 50 75 60 0 150 0 165 0 225 300 225 300 180
Circle -16777216 true false 180 180 90
Circle -16777216 true false 30 180 90
Polygon -16777216 true false 162 80 132 78 134 135 209 135 194 105 189 96 180 89
Circle -7500403 true true 47 195 58
Circle -7500403 true true 195 195 58

circle
false
0
Circle -7500403 true true 0 0 300

circle 2
false
0
Circle -7500403 true true 0 0 300
Circle -16777216 true false 30 30 240

cow
false
0
Polygon -7500403 true true 200 193 197 249 179 249 177 196 166 187 140 189 93 191 78 179 72 211 49 209 48 181 37 149 25 120 25 89 45 72 103 84 179 75 198 76 252 64 272 81 293 103 285 121 255 121 242 118 224 167
Polygon -7500403 true true 73 210 86 251 62 249 48 208
Polygon -7500403 true true 25 114 16 195 9 204 23 213 25 200 39 123

cylinder
false
0
Circle -7500403 true true 0 0 300

dot
false
0
Circle -7500403 true true 90 90 120

face happy
false
0
Circle -7500403 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 255 90 239 62 213 47 191 67 179 90 203 109 218 150 225 192 218 210 203 227 181 251 194 236 217 212 240

face neutral
false
0
Circle -7500403 true true 8 7 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Rectangle -16777216 true false 60 195 240 225

face sad
false
0
Circle -7500403 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 168 90 184 62 210 47 232 67 244 90 220 109 205 150 198 192 205 210 220 227 242 251 229 236 206 212 183

fish
false
0
Polygon -1 true false 44 131 21 87 15 86 0 120 15 150 0 180 13 214 20 212 45 166
Polygon -1 true false 135 195 119 235 95 218 76 210 46 204 60 165
Polygon -1 true false 75 45 83 77 71 103 86 114 166 78 135 60
Polygon -7500403 true true 30 136 151 77 226 81 280 119 292 146 292 160 287 170 270 195 195 210 151 212 30 166
Circle -16777216 true false 215 106 30

flag
false
0
Rectangle -7500403 true true 60 15 75 300
Polygon -7500403 true true 90 150 270 90 90 30
Line -7500403 true 75 135 90 135
Line -7500403 true 75 45 90 45

flower
false
0
Polygon -10899396 true false 135 120 165 165 180 210 180 240 150 300 165 300 195 240 195 195 165 135
Circle -7500403 true true 85 132 38
Circle -7500403 true true 130 147 38
Circle -7500403 true true 192 85 38
Circle -7500403 true true 85 40 38
Circle -7500403 true true 177 40 38
Circle -7500403 true true 177 132 38
Circle -7500403 true true 70 85 38
Circle -7500403 true true 130 25 38
Circle -7500403 true true 96 51 108
Circle -16777216 true false 113 68 74
Polygon -10899396 true false 189 233 219 188 249 173 279 188 234 218
Polygon -10899396 true false 180 255 150 210 105 210 75 240 135 240

house
false
0
Rectangle -7500403 true true 45 120 255 285
Rectangle -16777216 true false 120 210 180 285
Polygon -7500403 true true 15 120 150 15 285 120
Line -16777216 false 30 120 270 120

leaf
false
0
Polygon -7500403 true true 150 210 135 195 120 210 60 210 30 195 60 180 60 165 15 135 30 120 15 105 40 104 45 90 60 90 90 105 105 120 120 120 105 60 120 60 135 30 150 15 165 30 180 60 195 60 180 120 195 120 210 105 240 90 255 90 263 104 285 105 270 120 285 135 240 165 240 180 270 195 240 210 180 210 165 195
Polygon -7500403 true true 135 195 135 240 120 255 105 255 105 285 135 285 165 240 165 195

line
true
0
Line -7500403 true 150 0 150 300

line half
true
0
Line -7500403 true 150 0 150 150

pentagon
false
0
Polygon -7500403 true true 150 15 15 120 60 285 240 285 285 120

person
false
0
Circle -7500403 true true 110 5 80
Polygon -7500403 true true 105 90 120 195 90 285 105 300 135 300 150 225 165 300 195 300 210 285 180 195 195 90
Rectangle -7500403 true true 127 79 172 94
Polygon -7500403 true true 195 90 240 150 225 180 165 105
Polygon -7500403 true true 105 90 60 150 75 180 135 105

plant
false
0
Rectangle -7500403 true true 135 90 165 300
Polygon -7500403 true true 135 255 90 210 45 195 75 255 135 285
Polygon -7500403 true true 165 255 210 210 255 195 225 255 165 285
Polygon -7500403 true true 135 180 90 135 45 120 75 180 135 210
Polygon -7500403 true true 165 180 165 210 225 180 255 120 210 135
Polygon -7500403 true true 135 105 90 60 45 45 75 105 135 135
Polygon -7500403 true true 165 105 165 135 225 105 255 45 210 60
Polygon -7500403 true true 135 90 120 45 150 15 180 45 165 90

sheep
false
0
Rectangle -7500403 true true 151 225 180 285
Rectangle -7500403 true true 47 225 75 285
Rectangle -7500403 true true 15 75 210 225
Circle -7500403 true true 135 75 150
Circle -16777216 true false 165 76 116

square
false
0
Rectangle -7500403 true true 30 30 270 270

square 2
false
0
Rectangle -7500403 true true 30 30 270 270
Rectangle -16777216 true false 60 60 240 240

star
false
0
Polygon -7500403 true true 151 1 185 108 298 108 207 175 242 282 151 216 59 282 94 175 3 108 116 108

target
false
0
Circle -7500403 true true 0 0 300
Circle -16777216 true false 30 30 240
Circle -7500403 true true 60 60 180
Circle -16777216 true false 90 90 120
Circle -7500403 true true 120 120 60

tree
false
0
Circle -7500403 true true 118 3 94
Rectangle -6459832 true false 120 195 180 300
Circle -7500403 true true 65 21 108
Circle -7500403 true true 116 41 127
Circle -7500403 true true 45 90 120
Circle -7500403 true true 104 74 152

triangle
false
0
Polygon -7500403 true true 150 30 15 255 285 255

triangle 2
false
0
Polygon -7500403 true true 150 30 15 255 285 255
Polygon -16777216 true false 151 99 225 223 75 224

truck
false
0
Rectangle -7500403 true true 4 45 195 187
Polygon -7500403 true true 296 193 296 150 259 134 244 104 208 104 207 194
Rectangle -1 true false 195 60 195 105
Polygon -16777216 true false 238 112 252 141 219 141 218 112
Circle -16777216 true false 234 174 42
Rectangle -7500403 true true 181 185 214 194
Circle -16777216 true false 144 174 42
Circle -16777216 true false 24 174 42
Circle -7500403 false true 24 174 42
Circle -7500403 false true 144 174 42
Circle -7500403 false true 234 174 42

turtle
true
0
Polygon -10899396 true false 215 204 240 233 246 254 228 266 215 252 193 210
Polygon -10899396 true false 195 90 225 75 245 75 260 89 269 108 261 124 240 105 225 105 210 105
Polygon -10899396 true false 105 90 75 75 55 75 40 89 31 108 39 124 60 105 75 105 90 105
Polygon -10899396 true false 132 85 134 64 107 51 108 17 150 2 192 18 192 52 169 65 172 87
Polygon -10899396 true false 85 204 60 233 54 254 72 266 85 252 107 210
Polygon -7500403 true true 119 75 179 75 209 101 224 135 220 225 175 261 128 261 81 224 74 135 88 99

wheel
false
0
Circle -7500403 true true 3 3 294
Circle -16777216 true false 30 30 240
Line -7500403 true 150 285 150 15
Line -7500403 true 15 150 285 150
Circle -7500403 true true 120 120 60
Line -7500403 true 216 40 79 269
Line -7500403 true 40 84 269 221
Line -7500403 true 40 216 269 79
Line -7500403 true 84 40 221 269

wolf
false
0
Polygon -7500403 true true 135 285 195 285 270 90 30 90 105 285
Polygon -7500403 true true 270 90 225 15 180 90
Polygon -7500403 true true 30 90 75 15 120 90
Circle -1 true false 183 138 24
Circle -1 true false 93 138 24

x
false
0
Polygon -7500403 true true 270 75 225 30 30 225 75 270
Polygon -7500403 true true 30 75 75 30 270 225 225 270

@#$#@#$#@
NetLogo 5.0.1
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
<experiments>
  <experiment name="15thjuly" repetitions="20" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <final>calc-stats</final>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species-col</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <enumeratedValueSet variable="max-time">
      <value value="2000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="new-species-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0"/>
      <value value="0.0050"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;ecology&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="145"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="10"/>
      <value value="50"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.0050"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="2"/>
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="21june" repetitions="20" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <final>calc-stats</final>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <enumeratedValueSet variable="max-time">
      <value value="2000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="new-species-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.0050"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;ecology&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="145"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="10"/>
      <value value="20"/>
      <value value="30"/>
      <value value="40"/>
      <value value="50"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.0050"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="1"/>
      <value value="2"/>
      <value value="3"/>
      <value value="4"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="25 june" repetitions="20" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="new-species-prob">
      <value value="0.02"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="500"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="2"/>
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="60"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.0050"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
      <value value="200"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;ecology&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="0"/>
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.0050"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="2000"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="25 june-a" repetitions="10" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="new-species-prob">
      <value value="0.02"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="250"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="2"/>
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="60"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
      <value value="200"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;ecology&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="0"/>
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="2000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="6"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="6"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="analysis 1" repetitions="50" runMetricsEveryStep="false">
    <setup>setup
load-world
start-analysis</setup>
    <go>go</go>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="4"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <steppedValueSet variable="affected-char" first="0" step="1" last="16"/>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="5"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;ecology example 9&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="2205"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="200"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.0050"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="500"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="analysis 2" repetitions="50" runMetricsEveryStep="false">
    <setup>setup
load-world
set max-time 2155
start-analysis</setup>
    <go>go</go>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="4"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <steppedValueSet variable="affected-char" first="0" step="1" last="16"/>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="5"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;ecology example 9&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="2205"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="200"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.0050"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="500"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment 1 env char" repetitions="50" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;explore&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="1000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="500"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="0"/>
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="0"/>
      <value value="9"/>
      <value value="19"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="0"/>
      <value value="9"/>
      <value value="19"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment  8 lon" repetitions="1" runMetricsEveryStep="true">
    <setup>setup</setup>
    <go>go</go>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;explore long&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="100000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="rand-death-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="9"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment  4 env char" repetitions="30" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <final>calc-stats</final>
    <timeLimit steps="1001"/>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;explore 4&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="1000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
      <value value="50"/>
      <value value="100"/>
      <value value="150"/>
      <value value="200"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="rand-death-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="9"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment  5 env char" repetitions="20" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <final>calc-stats</final>
    <timeLimit steps="1001"/>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;explore 4&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="1000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
      <value value="50"/>
      <value value="100"/>
      <value value="150"/>
      <value value="200"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="rand-death-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="9"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment  6 env char" repetitions="10" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <final>calc-stats</final>
    <timeLimit steps="1001"/>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;explore 6&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="10"/>
      <value value="20"/>
      <value value="30"/>
      <value value="40"/>
      <value value="50"/>
      <value value="60"/>
      <value value="70"/>
      <value value="80"/>
      <value value="90"/>
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="1000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="rand-death-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="9"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment  7 env char" repetitions="20" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <final>calc-stats</final>
    <timeLimit steps="1001"/>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;explore 7&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="1000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0"/>
      <value value="0.025"/>
      <value value="0.05"/>
      <value value="0.075"/>
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="rand-death-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="9"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment  8 env char" repetitions="10" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <final>calc-stats</final>
    <timeLimit steps="1001"/>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;explore 8&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="1000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0"/>
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="rand-death-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="1"/>
      <value value="2"/>
      <value value="3"/>
      <value value="4"/>
      <value value="5"/>
      <value value="6"/>
      <value value="7"/>
      <value value="8"/>
      <value value="9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="1"/>
      <value value="2"/>
      <value value="3"/>
      <value value="4"/>
      <value value="5"/>
      <value value="6"/>
      <value value="7"/>
      <value value="8"/>
      <value value="9"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment  9 env char" repetitions="10" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <timeLimit steps="1001"/>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;explore 8&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="1000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0"/>
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="rand-death-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="0"/>
      <value value="5"/>
      <value value="9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="0"/>
      <value value="5"/>
      <value value="9"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment  10 env char" repetitions="10" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <final>calc-stats</final>
    <timeLimit steps="5000"/>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;explore 9&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="5000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0"/>
      <value value="0.01"/>
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="rand-death-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="4"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="0"/>
      <value value="1"/>
      <value value="2"/>
      <value value="3"/>
      <value value="4"/>
      <value value="5"/>
      <value value="6"/>
      <value value="7"/>
      <value value="8"/>
      <value value="9"/>
      <value value="10"/>
      <value value="11"/>
      <value value="12"/>
      <value value="13"/>
      <value value="14"/>
      <value value="15"/>
      <value value="16"/>
      <value value="17"/>
      <value value="18"/>
      <value value="19"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="test" repetitions="2" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <final>calc-stats</final>
    <timeLimit steps="501"/>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;test&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="500"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0"/>
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="rand-death-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="4"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="4"/>
    </enumeratedValueSet>
  </experiment>
  <experiment name="experiment  3 env char" repetitions="30" runMetricsEveryStep="false">
    <setup>setup</setup>
    <go>go</go>
    <timeLimit steps="1001"/>
    <metric>count turtles</metric>
    <metric>num-species</metric>
    <metric>cumm-num-species</metric>
    <metric>pi-t</metric>
    <metric>pi-d</metric>
    <metric>F-st</metric>
    <metric>pi-env</metric>
    <metric>F-env</metric>
    <metric>F-denv</metric>
    <metric>l0</metric>
    <metric>l1</metric>
    <metric>l2+</metric>
    <metric>s1</metric>
    <metric>s2</metric>
    <metric>s3</metric>
    <metric>s4</metric>
    <metric>s5</metric>
    <metric>s6</metric>
    <metric>s7</metric>
    <metric>s8</metric>
    <metric>s9</metric>
    <metric>s10</metric>
    <metric>s11</metric>
    <metric>s12</metric>
    <metric>s13</metric>
    <metric>s14</metric>
    <metric>s15</metric>
    <metric>s16</metric>
    <metric>pi1</metric>
    <metric>pi2</metric>
    <metric>pi3</metric>
    <metric>pi4</metric>
    <metric>pi5</metric>
    <metric>pi6</metric>
    <metric>pi7</metric>
    <metric>pi8</metric>
    <metric>pi9</metric>
    <metric>pi10</metric>
    <metric>pi11</metric>
    <metric>pi12</metric>
    <metric>pi13</metric>
    <metric>pi14</metric>
    <metric>pi15</metric>
    <metric>pi16</metric>
    <enumeratedValueSet variable="stop-new-species-once-established?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="title">
      <value value="&quot;explore&quot;"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="initial-species-variety">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="mut-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="life-tax">
      <value value="0.05"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-new-species-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="gene-size">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-time">
      <value value="1000"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="affected-char">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="init-energy">
      <value value="1"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="reproduce-level">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="efficiency">
      <value value="0.9"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="food-rate">
      <value value="100"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="eating-tries">
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migration-prob">
      <value value="0.01"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="neutral?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="migrate-near?">
      <value value="true"/>
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="num-env-chars">
      <value value="0"/>
      <value value="1"/>
      <value value="2"/>
      <value value="3"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="allow-cannibals?">
      <value value="false"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-age">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="anti-sym-mat?">
      <value value="true"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="rand-death-prob">
      <value value="0"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pxcor">
      <value value="0"/>
      <value value="9"/>
      <value value="19"/>
    </enumeratedValueSet>
    <enumeratedValueSet variable="max-pycor">
      <value value="0"/>
      <value value="9"/>
      <value value="19"/>
    </enumeratedValueSet>
  </experiment>
</experiments>
@#$#@#$#@
@#$#@#$#@
default
0.0
-0.2 0 1.0 0.0
0.0 1 1.0 0.0
0.2 0 1.0 0.0
link direction
true
0
Line -7500403 true 150 150 90 180
Line -7500403 true 150 150 210 180

@#$#@#$#@
0
@#$#@#$#@