Congressional Redistricting

patches-own [patch_pop district state counted]

to show_population_density_map
  ; clear world and import population density map
  ; map should be grayscale of population
  ca
  import-pcolors file-name

  ; initialize districts based on highest-population patches
  let num_districts 0
  ask patches [
    set patch_pop 100 * (10 - pcolor)
    set counted False
  ]

  ; determine points of highest population from density map
  let peak_pop_points []
  ask patches [
    if max [patch_pop] of neighbors < patch_pop [
      set peak_pop_points lput self peak_pop_points
    ]
  ]

  ; sort list by patch population in descending order
  set peak_pop_points sort-by [ [patch1 patch2] -> [patch_pop] of patch1 > [patch_pop] of patch2 ] peak_pop_points

  ; determine district centers, ensuring that neither the list of points nor the user-set max-districts is exceeded
  while [num_districts < length peak_pop_points and num_districts < max-districts] [
    ask item num_districts peak_pop_points [
      set num_districts num_districts + 1
      set district num_districts
      set state "edge"
      set pcolor yellow
    ]
  ]
end 

to generate_districts
  ; generate imported map of population density
  show_population_density_map
  let num_districts max ([district] of patches)

  ; expand districts to fill entire map
  while [any? patches with [state = 0]] [
    wait .1
    ask patches with [state = "edge"] [
      if any? neighbors4 with [state = 0] [
        ask one-of neighbors4 with [state = 0] [
          set district [district] of myself
          set state "edge"
          set pcolor yellow
        ]
      ]
      determine-state
    ]
  ]

  ; adjust districts to equalize population
  let total_pop sum ([patch_pop] of patches)
  let max_difference .05 ; districts can only be +/- this percent
  let done False
  while [not done] [
    wait .001

    ; cycle through districts
    let x 1
    while [x <= num_districts] [
      let district_pop sum ([patch_pop] of patches with [district = x])

      ; determine patch asking behavior depending on specified adjust-mode
      let selection []
      if adjust-mode = "smooth" [
        set selection patches with [state = "edge" and district = x]
      ]
      if adjust-mode = "jagged" [
        set selection one-of patches with [state = "edge" and district = x]
      ]

      ; increase district size if population is too low
      if district_pop < total_pop / num_districts * (1 - max_difference) [
        ask selection [
          let y neighbors4 with [state = "edge" and district != x]
          if any? y [
            ask one-of y [
              change-to x
              ask neighbors4 [determine-state]
              determine-state
            ]
          ]
        ]
      ]

      ; decrease district size if population is too high
      if district_pop > total_pop / num_districts * (1 + max_difference) [
        ask selection [
          change-to [district] of one-of neighbors4
          ask neighbors4 [determine-state]
          determine-state
        ]
      ]

      ; increment to next district
      set x x + 1
    ]

    ; check if districts are within population bounds
    ; i.e. if they have similar populations
    set done True
    set x 1
    while [x <= num_districts] [
      let district_pop sum ([patch_pop] of patches with [district = x])
      if district_pop < total_pop / num_districts * (1 - max_difference) or
      district_pop > total_pop / num_districts * (1 + max_difference) [
        set done False
      ]

      ; increment to next district
      set x x + 1
    ]
  ]

  ; show districts by color
  ask patches [
    set pcolor district * 20 - 1 - patch_pop / 120
  ]

  ; output district sizes
  let x 1
  output-print "Districts:"
  while [x <= num_districts] [
    let district_pop sum ([patch_pop] of patches with [district = x])
    output-print (word "D" x " - " district_pop " - " (int(district_pop / total_pop * 10000) / 100) "%")
    set x x + 1
  ]
  output-print "Total Population:"
  output-print total_pop
end 

to determine-state
  if-else any? neighbors4 with [district != [district] of myself]
  [
    set state "edge"
    set pcolor yellow
  ]
  [
    set state "done"
    set pcolor 9 - patch_pop / 120
  ]
end 

; have patch change to "new_district"
; checks if change keeps district continuous

to change-to [new_district]
  let original_district district
  set district new_district
  let remain_continuous True
  ask self [set remain_continuous check-continuous]
  if not remain_continuous [
    set district original_district
  ]
end 

; checks if the district(s) of the patches affected are continuous
; i.e. all patches in the district are connected

to-report check-continuous
  let report_bool True
  let affected_patches (patch-set self (neighbors4 with [district != [district] of myself]))
  ask affected_patches [
    ; define district and patches in district
    let district_name district
    let district_patches patches with [district = district_name]

    ; calculate district patches that are continuous with current patch
    ask district_patches [set counted False]
    let continuous_size 0
    ask one-of district_patches [
      set counted True
      set continuous_size count-continuous-patches
    ]

    ; calculate total patches in district
    let district_size count district_patches

    ; if the previous 2 calculations don't match, the district is not continuous
    if district_size != continuous_size [set report_bool False stop]
  ]
  report report_bool
end 

; recursive function that calculates the number of connected patches within district of patch

to-report count-continuous-patches
  let district_size 1
  let x neighbors4 with [not counted and district = [district] of myself]
  if any? x [
    ask x [set counted True]
    ask x [set district_size district_size + count-continuous-patches]
  ]
  report district_size
end