Bug Hunt Coevolution

Bug Hunt Coevolution preview image

2 collaborators

Uri_dolphin3 Uri Wilensky (Author)
Default-person Michael Novak (Author)

Tags

(This model has yet to be categorized with any tags)
Model group CCL | Visible to everyone | Changeable by group members (CCL)
Model was written in NetLogo 5.0.4 • Viewed 774 times • Downloaded 97 times • Run 2 times
Download the 'Bug Hunt Coevolution' modelDownload this modelEmbed this model

Do you have questions or comments about this model? Ask them here! (You'll first need to log in.)


WHAT IS IT?

This is a natural/artificial selection model that shows the interrelationship between natural selection forces in predator and prey that results from coevolution.

The model shows how genetic variability affects evolutionary processes and outcomes for the speed and sight of predators and prey. The model demonstrates many different series of reciprocal changes between a predator (birds) and prey (bugs) which each act as an agent of natural selection for each other, particularly related to the successive adaptation of the bird for pursuing its prey and the bugs for fleeing its prey.

By also adjusting the 1) initial values for speed and vision in predators (birds) and prey (bugs) and the size and shape of the world 2) the rate at which offspring in the population of birds and bugs incur mutations in genetics, various evolutionary outcomes will emerge from the coevolution of the birds and bugs (slow moving bugs vs. fast moving bugs, optimally sighted bugs, etc...).

HOW IT WORKS

Predator (bird) and prey (bug) populations coevolve as the selective pressures they exert on one another favor different attributes in vision and speed over time.

Press SETUP to create a population of bugs, determined by the six times the INITIAL-BUGS-EACH-SPEED slider. The bugs that are created are randomly distributed around the world and assigned a speed.

When you press GO the bugs begin to move at their designated speeds. As they move around any birds on the screen will try to eat as many bugs as they can by running into them.

The six different speeds that a bug might move at are distributed amongst six different sub-populations of the bugs. These speeds are genetically inherited. The bugs also have a sight value. This sight value is the distance within which the bug can see birds in their cone of vision (120 degrees arc) AND for which they respond to the presence of the bird, by turning around to head in the opposite direction. These vision values are genetically inherited. With each bug eaten (by a bird), a new bug is randomly chosen from the population to reproduce one offspring. This bug's new speed is copied from the parent and then randomly changed up or down by a small amount (determined by the BUG-SPEED-MUTATION slider) and the bug's new vision is copied from the parent and then randomly changed up or down by a small amount (determined by the BUG-VISION-MUTATION slider). The creation of this new offspring keeps the overall population of the bugs constant.

The number of birds that are in the world is determined by the INITIAL-BIRDS slider. The birds have an initial speed (INITIAL-BIRD-SPEED) and initial vision (INITIAL-BIRD-VISION) values. The birds respond to bugs in their vision cone by turning toward the bug they select using the specified BUG-PURSUIT-STRATEGY. The speed and vision of the birds, like the bugs, is genetically inherited. Variation is offspring speed and vision is controlled by BIRD-SPEED-MUTATION and BIRD-VISION-MUTATION. An update to the bird population occurs after a fixed number of bugs is eaten by the total population. At this point the bird who has eaten the least number of bugs since the last bird population update is removed (representing death from starvation), and a new bird is copied from an existing individual in the population (representing a new birth). The creation of this new offspring keeps the overall population of the birds constant.

Initially there are equal numbers of each sub-population of bug (e.g. ten bugs at each of the 6 speeds). This is the only inherited attribute that has a distribution of different values. The other attributes (vision for bugs and birds, and speed for birds) has only a single starting value for all of the members of the population.

Over time, however, as bugs are eaten and new bugs are born and birds die and new birds are born, the distribution of the vision and speed for both birds and bugs will change as shown in the histograms. In some scenarios you might see the speed distribution move to the left, representing that more slow individuals are surviving. In other scenarios you may see the vision histogram shift to the right, representing that more far sighted individuals are surviving. In some scenarios you will see the histogram shift toward some intermediate value and then remain relatively stable with a maximum number of individuals having that value in the histogram. Comparing the proportions of individuals with different values for vision and speed in the histograms to the average values of these attributes for the population, will help you make important links between how the population is evolving and how the individuals are being selected for or against, and how proportions of traits in the population are changing over time.

In addition to the automated predators (the birds), you may also assume the role of an additional predator amongst a population of bugs. To join in the pursuit of bugs as another bird simply use your mouse in the WORLD & VIEW to click on bugs and eat them as they move. As they move around, try to eat as many bugs as fast as you can by clicking on them. Alternatively, you may hold the mouse button down and move the mouse pointer over the bugs.

HOW TO USE IT

INITIAL-BUGS-EACH-SPEED is the number of bugs you start with in each of the six sub-populations. The overall population of bugs is determined by multiplying this value by 6.

INITIAL-BIRDS is the number of birds that you start with.

INITIAL-BIRD-SPEED is the speed that each bird starts with.

INITIAL-BIRD-VISION and INITIAL-BUG-VISION is the radius the vision cones that the birds and bugs initially start with.

BIRD-VISION-MUTATION, BIRD-SPEED-MUTATION, BUG-VISION-MUTATION, BUG-SPEED-MUTATION are each sliders that control the amount of maximum possible random mutation (up or down) in the value of the speed or vision that occur in the offspring.

SHOW-VISION-CONE? switch helps you visualize the vision detection and response cone of the birds and bugs.

BUG-FLEE-STRATEGY sets which predator the bug will turn away from - "nearest" or "any". BIRD-PURSUIT-STRATEGY sets which bug the bird will turn toward - "nearest" or "lock on one" (which means the bird keeps following the same bug until it is either outside its vision cone or it catches it. "None" will cause the bugs or birds not react at all to nearby prey or predators.

THINGS TO NOTICE

The SPEED-OF-BUGS histogram tends to shift right if you assume the role of chasing easy prey and the average speed of the bugs increases over time.

The SPEED-OF-BUGS histogram tends to shift left if you assume the role of waiting for prey come to you and the average speed of the bugs decreases over time. (The same effect is achieved with moving the mouse around the view randomly)

THINGS TO TRY

Set the model up with INITIAL-BUGS-EACH-SPEED set to one and INITIAL-BIRDS to 0. Slow the model down and watch where new bugs come from when you eat (by clicking the mouse on) a bug. You should see a new bug hatch from one of the five remaining and it should be moving at the same speed as its parent.

Chase bugs around trying to catch the bug nearest you at any one time by holding the mouse button down and moving the cursor around the view after the nearest bug.

Try using the model with just you as the predator and INITIAL-BIRDS set to 0. Watch how the bugs evolve over time in response to just you as a predator.

Then, watch how the bugs evolve in response to automated birds.

In each of these scenarios, use the "follow nearest" strategy setting in the choosers unless specified and set INITIAL-BIRDS to 10.

If you start with stationary birds (INITIAL-BIRD-SPEED 0) and the BIRD-SPEED-MUTATION slider to 0 and do not permit bug sight to evolve (BUG-VISION-MUTATION 0), but all other mutation sliders to .5 you will notice that over time that the bugs will evolve into very slow movers and bird sight will not change in a preferred direction.

If you start with moving birds (e.g. INITIAL-BIRD-SPEED 2) and no-sight birds and bugs (INITIAL-BUG-VISION 0 and INITIAL-BIRD-VISION 0), and do not permit bug sight to evolve (BUG-VISION-MUTATION 0) notice that the again, evolve into very slow movers at first, and then a bit later far seeing birds evolve.

If you start with moving birds and bugs with no sight, but allow the sights of both to mutate (but not speed), both birds and bugs will co-evolve their sight to a higher mid-level optimal value for sight in bugs and maximum sight in birds.

If you fix the vision of birds and bugs to 2 and also start with fast birds (10), the spread between the speed of bird and bugs will result in rapid evolution to slow moving bugs and then prevent any further evolution of speed OR vision of the bugs to higher levels.

If you fix the vision of birds and bugs to 2 and the start with a bird speed of 4 , but allow both bug and bird speed to evolve, this will result in coevolution toward maximum speed for both.

If you fix the vision fix the vision of both birds and bugs to 2 and start with a bird speed of 4 and allow everything to evolve, you will get speed co-evolution toward maximum, a short term evolution of short-sighted bugs at first, and then a turn around in direction of evolution toward a higher optimal mid-level of sight.

If you change the strategy of the predator to "lock-on-one" and repeat the previous experiment, the vision of the bugs evolves to a different optimal mid-level of sight than before (lower in value e.g. 3.5 vs. 5). There will be a slower response in the speed maximization of birds and bugs, and little selective pressure on the vision of the birds (can be a wide range of values).

If you repeat the last scenario but change the size and shape of the world, (e.g. a narrow rectangle), you will get a different optimal level for bug and bird sight. And you may get some other emergent behavior in the overall population of the bugs. For example world dimension of 4 x 16 will yield very low vision bugs and high vision birds and the emergence of a type of "herding" or "flocking" pattern in the population of bugs.

EXTENDING THE MODEL

Include inheritance of bugs' and predators' avoidance and pursuit strategies.

Include a primary producer (plants) that bugs need to eat to survive. Include energy as a way to model when bugs and predators die or reproduce (see WOLF SHEEP PREDATION model in models library). Give the plants reproducible characteristics.

Include territory boundaries to create geographically isolated sections of the world (like islands and mountain ranges) to see if subpopulations evolve in each region (see GENE DRIFT T INTERACT models in the models library).

RELATED MODELS

All BEAGLE Evolution models. In particular: Bug Hunt Speeds, Bug Hunt Camouflage, Wolf Sheep Predation, and GENE DRIFT T INTERACT

CREDITS AND REFERENCES

This model is a part of the BEAGLE curriculum (http://ccl.northwestern.edu/simevolution/beagle.shtml)

HOW TO CITE

If you mention this model in a publication, we ask that you include these citations for the model itself and for the NetLogo software:

  • Novak, M. and Wilensky, U. (2007). NetLogo Bug Hunt Coevolution model. http://ccl.northwestern.edu/netlogo/models/BugHuntCoevolution. Center for Connected Learning and Computer-Based Modeling, Northwestern Institute on Complex Systems, Northwestern University, Evanston, IL.
  • Wilensky, U. (1999). NetLogo. http://ccl.northwestern.edu/netlogo/. Center for Connected Learning and Computer-Based Modeling, Northwestern Institute on Complex Systems, Northwestern University, Evanston, IL.

COPYRIGHT AND LICENSE

Copyright 2007 Uri Wilensky.

CC BY-NC-SA 3.0

This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/ or send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

Commercial licenses are also available. To inquire about commercial licenses, please contact Uri Wilensky at uri@northwestern.edu.

Comments and Questions

Click to Run Model

breed [bugs bug]
breed [players player]
breed [birds bird]
breed [vision-cones vision-cone]


bugs-own [speed vision]
birds-own [speed target eaten vision]


globals [
    total-caught                 ;; keeps track of total number of bugs caught
    total-speed-6-caught         ;; keeps track of the number of bugs caught with speed of 6
    total-speed-5-caught         ;; keeps track of the number of bugs caught with speed of 5
    total-speed-4-caught         ;; keeps track of the number of bugs caught with speed of 4
    total-speed-3-caught         ;; keeps track of the number of bugs caught with speed of 3
    total-speed-2-caught         ;; keeps track of the number of bugs caught with speed of 2
    total-speed-1-caught         ;; keeps track of the number of bugs caught with speed of 1
    old-color-map                ;; keeps track of the previous value of the SPEED-COLOR-MAP chooser
    histogram-interval-size      ;; the value of the interval size for each bar of the histogram
    max-vision                   ;; upper limit for the maximum vision allowable for birds or bugs
    max-speed                    ;; upper limit for the maximum speed allowable for birds or bugs
    old-show-initial-bug-vision-cone?
    old-vision-cone-distance
    avg-bug-speed
    avg-bird-speed
    avg-bug-vision
    avg-bird-vision
    reproduce-birds-after-eating
    speed-factor                 ;; scalar used to adjust the speed of the all the bugs to make the catching of bugs appropriately difficult for different speed computers
  ]


;;;;;;;;;;;;;;;;;;;;;
;; Setup Procedures
;;;;;;;;;;;;;;;;;;;;;

to setup
  ca
  set total-caught 0
  set histogram-interval-size 1
  set old-show-initial-bug-vision-cone? 0
  set old-vision-cone-distance initial-bug-vision
  set reproduce-birds-after-eating 25
  set speed-factor 0.05
  set max-speed 10
  set max-vision 10

  ask patches [ set pcolor white ]   ;; white background
  create-bugs number-bugs [ set speed initial-bug-speed attach-vision-cone]

  ask bugs [
    set vision initial-bug-vision
    set shape "bug"
    setxy random-xcor random-ycor
  ]

  ;; the player breed contains one turtle that is used to represent
  ;;  a player of the bugs (a bird)
  create-players 1 [
    set shape "bird"
    set color brown
    set hidden? true
  ]

  create-birds number-birds [
    set vision initial-bird-vision
    set shape "bird-stationary"
    set color brown
    set hidden? false
    setxy random 100 random 100
    set speed initial-bird-speed
    attach-vision-cone
  ]

  ask vision-cones [set-visualize-vision-cone]
  reset-ticks
  do-plots
end 

to attach-vision-cone
  let parent-vision vision
  hatch 1 [

    set breed vision-cones
    create-link-from myself [tie]
    set shape "vision cone"
    set color gray

    set size parent-vision

    set-visualize-vision-cone

  ]
end 


;;;;;;;;;;;;;;;;;;;;;
;; Runtime Procedures
;;;;;;;;;;;;;;;;;;;;;

to go
  check-visualize-vision-cone-change
  check-player-caught
  check-bird-catch
  move-player
  move-bugs
  move-birds
  reproduce-birds

  tick
  update-variables
  do-plots
end 

to update-variables
  ifelse any? bugs
    [set avg-bug-speed mean [speed] of bugs   set avg-bug-vision mean [vision] of bugs ]
    [set avg-bug-speed 0]
  ifelse any? birds
    [set avg-bird-speed mean [speed] of birds    set avg-bird-vision mean [vision] of birds]
    [set avg-bird-speed 0]
end 

to reproduce-birds
  let worst-bird nobody
  if (total-caught mod  reproduce-birds-after-eating = 0 and total-caught > 0 and any? birds) [
    set worst-bird min-one-of birds [eaten]
    ask worst-bird [
       ask out-link-neighbors [set color red die]
       die]
    reproduce-one-bird
  ]
end 

to move-bugs
  let target-heading 0
  let candidate-predators nobody
  let predator nobody
  let all-predators (turtle-set birds players)
  ;; the speed factor is a scaling number used to adjust the amount all the bugs move
  ;; for example a speed-factor of 2, scales the speed of all the bugs so they are moving twice as fast
  ;; it is a useful slider to change for slower and faster computers, that might have the bugs
  ;; as a whole population moving too fast or too slow across the screen
  ask bugs [
    fd (speed * speed-factor)

    ifelse any? all-predators in-cone vision 120 [
       set candidate-predators all-predators in-cone vision  120

       if bug-flee-strategy = "any" and any? candidate-predators
         [set predator one-of candidate-predators]
       if bug-flee-strategy = "nearest" and any? candidate-predators
         [set predator min-one-of candidate-predators [distance myself]]

       set target-heading 180 + towards predator

       set heading target-heading
       set label-color black
       set label "!"
    ]
    [wiggle set label ""]

  ]
end 

to move-birds
  let prey-agent nobody
  let candidate-bugs nobody
  let closest-bug nobody
  let assigned-target? false
  ;; the speed factor is a scaling number used to adjust the amount all the bugs move
  ;; for example a speed-factor of 2, scales the speed of all the bugs so they are moving twice as fast
  ;; it is a useful slider to change for slower and faster computers, that might have the bugs
  ;; as a whole population moving too fast or too slow across the screen
  ask birds [
    set candidate-bugs bugs in-cone initial-bird-vision  120

    ifelse any? candidate-bugs [
      set closest-bug min-one-of  candidate-bugs [distance myself]
      if (target = nobody and bug-pursuit-strategy = "lock on one") [
        set prey-agent closest-bug
        set target prey-agent
        set heading towards prey-agent
        set label-color red - 2
        set label "!"
        set assigned-target? true
      ]

      if (bug-pursuit-strategy = "closest" and target != closest-bug) [
        set prey-agent closest-bug
        set target prey-agent
                set heading towards prey-agent
        set label-color red - 2
        set label "!"
        set assigned-target? true
      ]

      if (assigned-target? != false) [
        set target nobody
        set label ""
        wiggle
      ]
    ]
    [
      set target nobody
      set label ""
      wiggle
    ]
    fd (speed * speed-factor)
  ]
end 

to wiggle
  if wiggle? [
    right (random-float 30 * .05 / speed-factor)
    left (random-float 30 * .05 / speed-factor)
  ]
end 

to move-player
  ifelse (mouse-inside?)
    [ ask players [ setxy mouse-xcor mouse-ycor set hidden? false] ]
    [ ask players [ set hidden? true]]
end 

to check-player-caught
  let speed-of-caught 0
  let local-bugs 0
  ;; the mouse may move while we are doing calculations
  ;; so keep track of the current mouse position so
  ;; we do all the calculations with the same numbers
  let snap-mouse-xcor mouse-xcor
  let snap-mouse-ycor mouse-ycor
  if mouse-down? and mouse-inside? [
    set local-bugs bugs-on patch snap-mouse-xcor snap-mouse-ycor
    if (any? local-bugs) [
      set total-caught (total-caught + 1)
      ;; eat only one of the bugs at the mouse location
      ask one-of local-bugs  [
        set speed-of-caught speed
        if (speed-of-caught = 1) [ set total-speed-6-caught (total-speed-6-caught + 1) ]
        if (speed-of-caught = 2) [ set total-speed-5-caught (total-speed-5-caught + 1) ]
        if (speed-of-caught = 3) [ set total-speed-4-caught (total-speed-4-caught + 1) ]
        if (speed-of-caught = 4) [ set total-speed-3-caught (total-speed-3-caught + 1) ]
        if (speed-of-caught = 5) [ set total-speed-2-caught (total-speed-2-caught + 1) ]
        if (speed-of-caught = 6) [ set total-speed-1-caught (total-speed-1-caught + 1) ]
        ask out-link-neighbors [set color red die]
        die
      ]
      reproduce-one-bug  ;; replace the eaten bug with a random offspring from the remaining population
    ]
  ]
end 

to check-bird-catch
  let speed-of-caught 0
  ask birds [
   if (any? bugs-here) [
      set total-caught (total-caught + 1)
      set eaten (eaten + 1)
      ;; eat only one of the bugs at the mouse location
      ask one-of bugs-here [
        set speed-of-caught speed
        if (speed-of-caught = 1) [ set total-speed-6-caught (total-speed-6-caught + 1) ]
        if (speed-of-caught = 2) [ set total-speed-5-caught (total-speed-5-caught + 1) ]
        if (speed-of-caught = 3) [ set total-speed-4-caught (total-speed-4-caught + 1) ]
        if (speed-of-caught = 4) [ set total-speed-3-caught (total-speed-3-caught + 1) ]
        if (speed-of-caught = 5) [ set total-speed-2-caught (total-speed-2-caught + 1) ]
        if (speed-of-caught = 6) [ set total-speed-1-caught (total-speed-1-caught + 1) ]
         ask out-link-neighbors [set color red die]
        die

      ]
      set target nobody
      reproduce-one-bug  ;; replace the eaten bug with a random offspring from the remaining population
    ]
  ]
end 

;; reproduce one identical offspring from one
;; of the bugs remaining in the population

to reproduce-one-bug
  ask one-of bugs [
    hatch 1 [
    mutate-offspring-bug
    set heading (random-float 360)

    attach-vision-cone
    ]
  ]
end 

to reproduce-one-bird
  let bird-energy-split 0
  if count birds > 0 [ask one-of birds [
    set bird-energy-split (eaten / 2)
    set eaten bird-energy-split
    hatch 1 [
    mutate-offspring-bird
    set heading (random-float 360)

    attach-vision-cone
    ]
  ]
  ]
end 

to mutate-offspring-bug
  ifelse random 2 = 0
    [set vision (vision + random-float bug-vision-mutation)]
    [set vision (vision - random-float bug-vision-mutation)]

  if vision > max-vision [set vision max-vision]
  if vision < 0 [set vision 0]

  ifelse random 2 = 0
    [set speed (speed + random-float bug-speed-mutation )]
    [set speed (speed - random-float bug-speed-mutation )]

  if speed > max-speed [set speed max-speed]
  if speed < 0 [set speed 0]
end 

to mutate-offspring-bird
  ifelse random 2 = 0
    [set vision (vision + random-float bird-vision-mutation )]
    [set vision (vision - random-float bird-vision-mutation )]

  if vision > max-vision [set vision max-vision]
  if vision < 0 [set vision 0]

  ifelse random 2 = 0
       [set speed (speed + random-float bird-speed-mutation)]
       [set speed (speed - random-float bird-speed-mutation)]

  if speed > max-speed [set speed max-speed]
  if speed < 0 [set speed 0]
end 

;;;;;;;;;;;;;;;;;;;;;
;; Visualization Procedures
;;;;;;;;;;;;;;;;;;;;;

to check-visualize-vision-cone-change
  if (old-show-initial-bug-vision-cone? != show-vision-cone?) [
    set old-show-initial-bug-vision-cone? show-vision-cone?
    ask vision-cones [set-visualize-vision-cone]
  ]
  if (old-vision-cone-distance != initial-bug-vision) [
    set old-vision-cone-distance initial-bug-vision
    ask vision-cones [set-visualize-vision-cone]
  ]
end 

to set-visualize-vision-cone
  let parent-vision [vision] of one-of in-link-neighbors
    ifelse show-vision-cone?
      [set hidden? false set size 2 * parent-vision]
      [set hidden? true set size 2 * parent-vision]
end 

to recolor-shade
  ;; turtle procedure to set color of the bugs to various shapes of purple
  set color (111 + speed )
end 

to recolor-rainbow ;; turtle procedure
  if (floor speed = 6) [ set color red ]
  if (floor speed = 5) [ set color orange ]
  if (floor speed = 4) [ set color (yellow - 1) ]  ;;  darken the yellow a bit for better visibility on white background
  if (floor speed = 3) [ set color green ]
  if (floor speed = 2) [ set color blue ]
  if (floor speed = 1) [ set color violet ]
  if (floor speed >= 7) [ set color gray - 2 ]
  if (floor speed < 1) [ set color gray + 2 ]
end 

;;;;;;;;;;;;;;;;;;;;;;
;; Plotting Procedures
;;;;;;;;;;;;;;;;;;;;;;

to do-plots
  if ticks mod 100 = 1
  [
    set-current-plot "Avg. Vision vs. Time"
    set-current-plot-pen "bugs"

    if any? bugs [plotxy ticks avg-bug-vision]
    set-current-plot-pen "birds"
    if any? birds [plotxy ticks avg-bird-vision]

    set-current-plot "Avg. Speed vs. Time"
    set-current-plot-pen "bugs"
    if any? bugs [plotxy ticks avg-bug-speed]
    set-current-plot-pen "birds"
    if any? birds [plotxy ticks avg-bird-speed]

    set-current-plot "Speed of Bugs"
    plot-histograms-bugs-speed

    set-current-plot "Vision of Bugs"
    plot-histograms-initial-bug-vision

    set-current-plot "Speed of Birds"
    plot-histograms-initial-bird-speed

    set-current-plot "Vision of Birds"
    plot-histograms-initial-bird-vision
  ]
end 

to plot-caught
  set-current-plot-pen "speed=1"
  plotxy ticks total-speed-1-caught
  set-current-plot-pen "speed=2"
  plotxy ticks total-speed-2-caught
  set-current-plot-pen "speed=3"
  plotxy ticks total-speed-3-caught
  set-current-plot-pen "speed=4"
  plotxy ticks total-speed-4-caught
  set-current-plot-pen "speed=5"
  plotxy ticks total-speed-5-caught
  set-current-plot-pen "speed=6"
  plotxy ticks total-speed-6-caught
end 

to plot-populations

  set-current-plot-pen "speed=1"
  plot (count bugs with [ speed = 1 ])
  set-current-plot-pen "speed=2"
  plot (count bugs with [ speed = 2 ])
  set-current-plot-pen "speed=3"
  plot (count bugs with [ speed = 3 ])
  set-current-plot-pen "speed=4"
  plot (count bugs with [ speed = 4 ])
  set-current-plot-pen "speed=5"
  plot (count bugs with [ speed = 5 ])
  set-current-plot-pen "speed=6"
  plot (count bugs with [ speed = 6 ])
end 

to plot-histograms-bugs-speed
  ;; creates 6 different histograms of different colors in the same graph
  ;; each histogram is color coded to the color mapping for when the
  ;; SPEED-COLOR-MAP chooser is set to "rainbow" value.


  set-histogram-num-bars 10
  set-current-plot-pen "#"
  set-plot-pen-interval histogram-interval-size
  histogram [ speed ] of bugs ;;with [speed >= 0 and speed < 1]
end 

to plot-histograms-initial-bug-vision
  ;; creates 6 different histograms of different colors in the same graph
  ;; each histogram is color coded to the color mapping for when the
  ;; SPEED-COLOR-MAP chooser is set to "rainbow" value.

  set-histogram-num-bars 10
  set-current-plot-pen "#"
  set-plot-pen-interval (histogram-interval-size )
  histogram [ vision ] of bugs
end 

to plot-histograms-initial-bird-speed
  ;; creates 6 different histograms of different colors in the same graph
  ;; each histogram is color coded to the color mapping for when the
  ;; SPEED-COLOR-MAP chooser is set to "rainbow" value.

  set-histogram-num-bars 10
  set-current-plot-pen "#"
  set-plot-pen-interval (histogram-interval-size )
  histogram [ speed ] of birds
end 

to plot-histograms-initial-bird-vision
  ;; creates 6 different histograms of different colors in the same graph
  ;; each histogram is color coded to the color mapping for when the
  ;; SPEED-COLOR-MAP chooser is set to "rainbow" value.

  set-histogram-num-bars 10
  set-current-plot-pen "#"
  set-plot-pen-interval (histogram-interval-size )
  histogram [ vision ] of birds
end 


; Copyright 2007 Uri Wilensky.
; See Info tab for full copyright and license.

There are 11 versions of this model.

Uploaded by When Description Download
Uri Wilensky over 11 years ago Updated to NetLogo 5.0.4 Download this version
Uri Wilensky about 12 years ago Updated version tag Download this version
Uri Wilensky about 12 years ago Updated to version from NetLogo 5.0.3 distribution Download this version
Uri Wilensky over 12 years ago Updated to NetLogo 5.0 Download this version
Uri Wilensky almost 13 years ago Updated to NetLogo 5.0 Download this version
Uri Wilensky over 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky over 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky over 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky over 14 years ago Updated from NetLogo 4.1 Download this version
Uri Wilensky over 14 years ago Model from NetLogo distribution Download this version
Uri Wilensky over 14 years ago Bug Hunt Coevolution Download this version

Attached files

File Type Description Last updated
Bug Hunt Coevolution.png preview Preview for 'Bug Hunt Coevolution' over 11 years ago, by Uri Wilensky Download

This model does not have any ancestors.

This model does not have any descendants.