IranBargaining

extensions [matrix]
globals [input-data agents data-matrix data-row-list
  exercised-powers saliences positions influences
  positions-normalized
  weighted-median weighted-median-position 
  apa-table
  agent-max parameter-list
  p1 p2 ; mnemononic for parameter 1, parameter 2; dummies
  ]

;; This procedure is being depricated so that a single Netlogo
;; file can be uploaded to the Modeling Commons.
;to load-input-data
;  ifelse ( file-exists? "BuenodeMesquita1984.txt" )
;  [
;  set input-data []
;  ;; This opens the file, so we can use it.
;  file-open "BuenodeMesquita1984.txt"
;  let file-header file-read-line
;  show file-header
;  while [ not file-at-end? ]
;  [  
;    set input-data sentence input-data (list (list file-read file-read file-read file-read))
;  ]
;  ;show input-data
;  file-close
;  make-data-structures
;  ]
;  [user-message "There is no BuenodeMesquita1984.txt file in current directory!" ]
;end

to load-default-data
   let default-data [["Agent" "Position" "Salience" "Influence"] ["UMC" 0 0.8 1.1] ["TEC" 0 2.5 0.6] ["MCR" 2.1 2.5 0.9] ["SOV" 3 10.3 0.6] ["PM" 4.7 6.8 9] ["BAZ" 5.1 0.8 5.6] ["REV" 5.1 8.5 12.4] ["JC" 5.1 10.3 11.3] ["PRE" 6.4 10.3 10.7] ["UP" 7.3 2.5 4.5] ["LCR" 7.3 3.4 4.5] ["KUR" 8.6 4.3 2.3] ["COM" 9.8 8.5 11.8] ["SC" 11.1 6 4.5] ["CG" 11.1 4.3 9] ["MON" 12.4 9.4 0.1] ["TMC" 12.4 9.4 3.4] ["QUM" 12.4 9.4 4.5]]
   set input-data default-data
   make-data-structures
end 

;; This procedure does the same thing as the above one, except it lets the user choose
;; the file to load from.  Note that we need to check that it isn't false.  This because
;; it will return false if the user cancels the file dialog.  There is currently only
;; one file to load from, but you can create your own using the function save-patch-data
;; near the bottom which saves all the current patches into a file.

to load-own-input-data
  let file user-file

  if ( file != false )
  [
    set input-data []
    file-open file
    let file-header file-read-line
    show file-header
    while [ not file-at-end? ]
      [ set input-data sentence input-data (list (list file-read file-read file-read file-read)) ]

    user-message "File loading complete!"
    file-close
    make-data-structures
  ]
end 

to show-input-data
  ifelse ( is-list? input-data )
    [ clear-output
      foreach input-data [ output-print ? ]]
    [ user-message "You need to load in patch data first!" ]
end 

to show-current-data
  ifelse ( is-list? agents )
    [ clear-output
      output-print (word "Agent Position Salience Influence")
      output-print "-------------------------------------"
      foreach n-values length agents [?] [ output-print (word item ? agents " " item ? positions " " item ? saliences " " item ? influences)]]
    [ user-message "You need to load in data first!" ]
end 

to model-report
  ifelse ( is-list? input-data )
  [ clear-output
    foreach input-data [ output-print ? ]
  ;; Now do the report on the selected model.
  if model = 1 [
    user-message "Valid model! Will run report."
    model1
  ]
  if model = 2 [
    user-message "Valid model! Will run report."
    model2
  ]
  ]
    [ user-message "You need to load in input data first!" ]
end 

to get-agent-list
  ifelse ( is-list? input-data )
  [ clear-output
    set agents []
    foreach input-data [ set agents lput item 0 ? agents ]
  ;; Now do the report on the selected model.
  set agents but-first agents
  ;show agents
  ]
  [ user-message "You need to load in input data first!" ]
end 

to make-row-list
  ;; Of the input-data
  ifelse ( is-list? input-data )
  [ clear-output
    set data-row-list []
    foreach input-data [ set data-row-list lput but-first ? data-row-list ]
  set data-row-list but-first data-row-list
  ;output-show data-row-list
  ]
  [ user-message "You need to load in input data first!" ]
end   

to make-data-array
  make-row-list
  set data-matrix matrix:from-row-list data-row-list
end 

to make-data-structures
  get-agent-list
  make-data-array
  ;; The following all report lists, not matrices.
  ;; Of course the lists can be easily converted to matrices as needed.
  set positions matrix:get-column data-matrix 0
  set saliences matrix:get-column data-matrix 1
  set influences matrix:get-column data-matrix 2
  ;; Now normalize the positions
;  set positions-normalized []
;  let damax max positions
;  let damin min positions
;  foreach positions [
;   set positions-normalized lput ((? - damin) / (damax - damin)) positions-normalized
;  ]
  set positions-normalized normalize-list (positions)
  set agent-max  length agents - 1
end 

to-report normalize-list [to-normalize]
  let normalized []
  let damax max to-normalize
  let damin min to-normalize
  foreach to-normalize [
   set normalized lput ((? - damin) / (damax - damin)) normalized
  ]
  report normalized
end 

to model1
  clear-output
  output-print "Results from model 1"
  make-exercised-powers
  make-weighted-median-position
  output-print (word "Weighted median value: " (round (100 * weighted-median) / 100))
  output-print (word "Weighted median position: " weighted-median-position)
end 

to model2
  clear-output
  output-print "Results from model 2"
  let row-sums-list model2prediction (positions)
  ;let row-sums matrix:from-column-list (list agents row-sums-list)
  output-print "The group attractiveness sums are:"
  foreach n-values length agents [?] [
  output-print (word item ? agents " " ((round (100 * item ? row-sums-list)) / 100 ) ) ; matrix:pretty-print-text row-sums
  ]
  output-print "The maximum attractiveness sum is:"
  output-print max row-sums-list
end 

to make-exercised-powers
  ifelse ( is-list? input-data )
  [ let s matrix:from-column-list (list saliences)
    let i matrix:from-column-list (list influences)
    set exercised-powers matrix:times-element-wise s i
    ;; exercised-powers is now a matrix.
    ;; Convert it to a list
    set exercised-powers first matrix:to-column-list exercised-powers
  ]
  [ user-message "You need to load in input data first!" ]
end 

to-report get-exercised-powers [s i]
  ;; s ~ saliences
  ;; i ~ influences
  let ss matrix:from-column-list (list s)
  let ii matrix:from-column-list (list i)
  let ep matrix:times-element-wise ss ii
  ;; exercised-powers is now a matrix.
  ;; Convert it to a list
  let eplist first matrix:to-column-list ep
  ;show eplist
  report eplist
end 

to make-weighted-median-position
  ifelse (exercised-powers = 0)
  [user-message "You need to create exercised-powers first! Use: make-exercised-powers"]
  [set weighted-median (sum exercised-powers) / 2
   let sofar 0
   let found []
   foreach exercised-powers [
     set sofar sofar + ?
     ifelse sofar <= weighted-median
     [set found lput 0 found]
     [set found lput 1 found]
   ]
    ;show found
    let pos position 1 found
    set weighted-median-position item pos agents
    ;show weighted-median-position
    ]
end 

to-report get-weighted-median-position [expow]
   let wt-median (sum expow) / 2
   let sofar 0
   let found []
   foreach expow [
     set sofar sofar + ?
     ifelse sofar <= wt-median
     [set found lput 0 found]
     [set found lput 1 found]
   ]
    ;show found
    let pos position 1 found
    report item pos agents
end 

to test
;  set bob matrix:from-column-list (list agents)
;  show bob
let bobw (list 1 2 3 "not bob")
let carol bobw
set carol lput 4 carol
set bobw fput 19 bobw
show carol
show bobw
end 

to display-agents
  let start (length agents) + 1
  foreach agents [
    ask patch 1 start [set plabel ?]
    set start (start - 1)
  ]
end 

to individual-exp [x-percent variable]
  clear-patches
  display-agents
  if (model = 1) [
  let hold-values []
  if runresult variable = saliences
  [ ;; So we fix influences and vary saliences
    ;;
    ;; First we modify the salience value for the agent.
    ;; Then we get the exercised power for the agent.
    ;; Then we get the weighted median position for the group,
    ;; and append it to hold-values.
    ;; Then we reset the salience value for the agent.
    ;; We continue this way until all agents have been processed.
    ;; The we print out the hold-values list.
    foreach n-values length agents [?]
    [
    ;; ok, once through
    let temp runresult variable
    ;show temp
    let target-value item ? temp
    ;show target-value
    let factor (1 + (x-percent / 100)) ;1.1
    ;show (word "factor = " factor)
    let new-value (target-value * factor) 
    ;show new-value
    set temp replace-item ? temp new-value
    ;show runresult variable
    ;show temp
    ;; OK, now get the new exercised powers
    let ex-powers get-exercised-powers(temp)(influences)
    ;show ex-powers
    ;; Now get the weighted median position for the group,
    ;; and append it to hold-values.
    set hold-values lput get-weighted-median-position(ex-powers) hold-values
    ]
   ] ; end of if runresult variable = saliences
  if runresult variable = influences
  [ foreach n-values length agents [?]
    [
    ;; ok, once through
    let temp runresult variable
    ;show temp
    let target-value item ? temp
    ;show target-value
    let factor (1 + (x-percent / 100)) ;1.1
    ;show (word "factor = " factor)
    let new-value (target-value * factor) 
    ;show new-value
    set temp replace-item ? temp new-value
    ;show runresult variable
    ;show temp
    ;; OK, now get the new exercised powers
    let ex-powers get-exercised-powers(saliences)(temp)
    ;show ex-powers
    ;; Now get the weighted median position for the group,
    ;; and append it to hold-values.
    set hold-values lput get-weighted-median-position(ex-powers) hold-values
    ]
    
    ]
   paint-values(hold-values)(3)
   if runresult variable = positions
   [user-message "Positions are not relevant to this model for post-solution analysis."]  
  ] ; end of if (model = 1)
  ;; Now, the next model, model 2.
  if (model = 2) [
    ;; A more complicated model.
    ;; We begin by constructing the APA table (agent position attractiveness)
    ;; This table is n by n where n is the number of agents = number of postions.
    ;; We'll make it with a matrix, initially of 0s
;    let dasize length agents
;    set apa-table matrix:make-constant dasize dasize 0
;    foreach n-values dasize [?]
;    [let row ?
;     foreach n-values dasize [?]
;      [let col ? 
;       let row-position item row positions-normalized
;       let theta item col positions-normalized
;       matrix:set apa-table row col 1 - abs(row-position - theta)
;      ]
;    ]
    ;print matrix:pretty-print-text apa-table
    ;; Now, get the row sums.
    let row-sums-list model2prediction (positions)
;    let row-sums matrix:from-column-list (list agents row-sums-list)
;    print matrix:pretty-print-text row-sums
;    print max row-sums-list
  let hold-values-model2 []
  if runresult variable = positions
  [ ;; So we fix influences and vary saliences
    ;;
    ;; First we modify the salience value for the agent.
    ;; Then we get the exercised power for the agent.
    ;; Then we get the weighted median position for the group,
    ;; and append it to hold-values.
    ;; Then we reset the salience value for the agent.
    ;; We continue this way until all agents have been processed.
    ;; The we print out the hold-values list.
    foreach n-values length agents [?]
    [
    ;; ok, once through
    let temp runresult variable
    ;show temp
    let target-value item ? temp
    ;show target-value
    let factor (1 + (x-percent / 100)) ;1.1
    ;show (word "factor = " factor)
    let new-value (target-value * factor) 
    ;show new-value
    set temp replace-item ? temp new-value
    ;show runresult variable
    ;show temp
    ;; OK, now get the new exercised powers
    let row-sums-list-new model2prediction (temp)
    ;show ex-powers
    ;; Now get the weighted median position for the group,
    ;; and append it to hold-values.
    set hold-values-model2 lput (item (position (max row-sums-list-new) row-sums-list-new) agents) hold-values-model2
    ]
    paint-values(hold-values-model2)(3)
   ] ; end of if runresult variable = positions    
   if runresult variable = saliences
   [user-message "Saliences are not relevant to this model."]
   if runresult variable = influences
   [user-message "Influences are not relevant to this model."]   
  ] ; end of if (model = 2)
end 

to-report model2prediction [thepositions]
  ;; First, normalize the positions
  let thepositions-normalized normalize-list (thepositions)
  let dasize length agents
  set apa-table matrix:make-constant dasize dasize 0
  foreach n-values dasize [?]
  [let row ?
   foreach n-values dasize [?]
    [let col ? 
     let row-position item row thepositions-normalized
     let theta item col thepositions-normalized
     matrix:set apa-table row col 1 - abs(row-position - theta)
    ]
  ]  
  ;; Now, get the row sums.
  let row-sums []
  foreach n-values dasize [?]
  [set row-sums (lput sum matrix:get-row apa-table ? row-sums)]
  ;; Now we have to find the max and get the associated position.
  ;; Complicating this is the possibility of ties.
  ;; I think the best thing to do is to report the whole thing,
  ;; as follows.
  ;let max-row-sum-value max row-sums
  report row-sums
  ;report apa-table
end 

to paint-values [value-list column]
  let start (length agents) + 1
  foreach value-list [
    ask patch column start [set plabel ?]
    set start (start - 1)
  ]
end 

to group-sampling-exploration [x-percent variable]
  clear-patches
  display-agents
  ;; set the outcome counts to 0
  foreach n-values length agents [?] [
    ask patch 5 (length agents + 1 - ?) [set plabel 0]
  ]

  if (model = 1) [
  if runresult variable = saliences
  [runresults-saliences-model1 (x-percent) ] ; end of if runresult variable = saliences  
  ;; Ok, now do influences
  if runresult variable = influences
  [runresults-influences-model1 (x-percent) ] ; end of if runresult variable = influences
  if runresult variable = positions
  [user-message "Positions do not apply for post-solution exploration in model 1."]
  
  
  ] ; end of if (model = 1)
  
  ;; Now model 2. key is: model2prediction (positions)
  if (model = 2) [
  if runresult variable = positions 
  [runresults-positions-model2 (x-percent)] ; end of if runresult variable = positions
  if runresult variable = influences
  [user-message "Influences do not apply for post-solution exploration in model 2."]
  if runresult variable = saliences
  [user-message "Saliences do not apply for post-solution exploration in model 2."]
  ] ; end of if (model = 2)
end 

to runresults-positions-model2 [x-percent]
  repeat runresult numtrials [
  ;; Copy positions to a new variable,new-values-positions
  let new-values-positions positions
  ;; Modify all of the positions randomly, uniformly in
  ;; plus/minus x-percent/100.
  foreach n-values length agents [?] [
    let upper item ? new-values-positions * (1 + (abs(x-percent) / 100))
    let lower max (list 0 (item ? new-values-positions * (1 - (abs(x-percent) / 100))))
    let new-value random-float (upper - lower)
    set new-value (lower + new-value)
    set new-values-positions replace-item ? new-values-positions new-value
  ]  
  ;; Solve the model, yielding a list of the summed position evaluations.
  let summed-position-evaluations model2prediction (new-values-positions)
  ;; Now we need to get the location of the first maximum value.
  ; set hold-values-model2 lput (item (position (max row-sums-list-new) row-sums-list-new) agents) hold-values-model2
  let new-position-index position (max summed-position-evaluations) summed-position-evaluations
  let new-position item new-position-index agents
  ;print (word "New outcome is " new-position)
  add-sample-count (new-position)
  ] ; end of repeat runresult numtrials
end 

to runresults-saliences-model1 [x-percent ]
  repeat runresult numtrials [    
    ;; First we modify the salience values for every agent.
    let new-values-saliences saliences
    foreach n-values length agents [?] [
      let upper item ? new-values-saliences * (1 + (abs(x-percent) / 100))
      let lower max (list 0 (item ? new-values-saliences * (1 - (abs(x-percent) / 100))))
      let new-value random-float (upper - lower)
      set new-value (lower + new-value)
      set new-values-saliences replace-item ? new-values-saliences new-value
    ]
    ;; Ok, now we solve the model to get the predicted position
    ;; OK, now get the new exercised powers
    let ex-powers get-exercised-powers(new-values-saliences)(influences)   
    ;; new-outcome refers to the agent (a string)
    let new-outcome get-weighted-median-position(ex-powers)
    add-sample-count (new-outcome)
  ] ; end of repeat runresult
end 

to runresults-influences-model1 [x-percent]
  repeat runresult numtrials [    
  ;; First we modify the salience values for every agent.
  let new-values-influences influences
  foreach n-values length agents [?] [
    let upper item ? new-values-influences * (1 + (abs(x-percent) / 100))
    let lower max (list 0 (item ? new-values-influences * (1 - (abs(x-percent) / 100))))
    let new-value random-float (upper - lower)
    set new-value (lower + new-value)
    set new-values-influences replace-item ? new-values-influences new-value
  ]
  ;; Ok, now we solve the model to get the predicted position
  ;; OK, now get the new exercised powers
  let ex-powers get-exercised-powers(saliences) (new-values-influences)  
  ;; new-outcome refers to the agent (a string)
  let new-outcome get-weighted-median-position(ex-powers)
  add-sample-count (new-outcome)
] ; end of repeat numtrials 
end 

to add-sample-count [outcome]
    let new-agent position outcome agents  
    let x-index 5
    let y-index (length agents + 1 - new-agent)
    ask patch x-index y-index [set plabel (plabel + 1)]
end