Evolutive Two-Way Network Formation

;;;;;;;;;;;;
;; This is the case for undirected graphs, genome is created by strictly upper triangular matrixes;;
;;;;;;;;;;;;

;;;;;;;;;;;;
;; Breeds ;;
;;;;;;;;;;;;

  ;; nodes and edges between nodes, are all turtles
  ;; edges are not necessarily symmetric
breed [ nodes node ]
breed [ edges edge ]


;;;;;;;;;;;;;;;
;; Variables ;;
;;;;;;;;;;;;;;;

globals [
   
  clock
  list-of-nodes   ;; nodes ordered by reservation price
  nodes-in-round  ;; nodes who have bought a product in the session
  avg-information-value
  nodos-accesibles
               
    ;; average number of nodes reachable by each buyer
    ;; in an infinite number of steps
  avg-accessibility
  
    ;; variable for drag-and-drop procedure
  clicked-node      ;; buyer who was clicked on
  path
  my-random-seed
  basic-genome 
  topology
  strict-upper-triang
  topology-random
  sum-fitness
  ranking
  empty-topology
  complete-topology
  density
  sum-links 
   
    ;; genetic algorithm variables
  generation
         
        edge-cost
         fitlist
         edgelist
         best-fitness
         avg-fitness
         avg-dir
         avg-ind
         max-profits
         profits
         net-indirect-benefit
         net-direct-benefit
         global-fitness
         seed-genomes
         mix-genes
         chosen-size
         genome-size
         best-genome
         adjacency-matrix     
         ;indirect-info
         transitive-matrix
         
          genome-list 
          topology-list

          random-wife1
          random-wife2
          random-husband1
          random-husband2
          winner-list
 ]

nodes-own [
    ;; stores the list of nodes that this particular buyer edges to
  edgeees
    ;; these variables are used to do the layout
  force-x
  force-y
         genome           
           fitness
           own-information
           direct-information
           indirect-info
           indirect-information
           direct-edgeing-costs
           indirect-edgeing-costs
                     
            origin
            destination  
          ]

  ;; The direction of the edge does matter in this model.
edges-own [
        origin 
        destination
         ]

;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Nodes Procedures ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;

  ;; accessibility is the number of social neighbours that the node could reach in a 
  ;; number of steps equal to "num-steps". For instance, if buyer A edges only to buyer B, 
  ;; who edges only to buyer C, who has no social neighbours, then A's accessibility 
  ;; in one step is 1, and in two steps is 2; B's accessibility in any number of steps is 1, 
  ;; and C's accessibility in any number of steps is 0.
  ;; This is what I need for counting accumulative edgeing costs!!

to-report accessibility [num-steps]
  set nodos-accesibles []
  let step 1
  let reachable-nodes edgeees
  let old-length 0
  let new-length length reachable-nodes
  while [ new-length != old-length and step < num-steps]
        [ set old-length new-length
          set reachable-nodes 
            remove-duplicates sentence 
              reachable-nodes 
              reduce [sentence ?1 ?2] map [ [edgeees] of ?] reachable-nodes 
          set new-length (length reachable-nodes)
          set nodos-accesibles fput reachable-nodes nodos-accesibles
          set step (step + 1)
        ]
        
  set path new-length - ifelse-value (member? self reachable-nodes) [1] [0]
  report path
end 

to-report accessibility-by-node [tag-node num-steps]
  let step 1
  let node-zero node tag-node
  let reachable-nodes [edgeees] of node-zero
  let old-length 0
  let new-length length reachable-nodes
  while [ new-length != old-length and step < num-steps]
        [ set old-length new-length
          set reachable-nodes 
            remove-duplicates sentence 
              reachable-nodes 
              reduce [sentence ?1 ?2] map [ [edgeees] of node ?] reachable-nodes 
          set new-length (length reachable-nodes)
          set step (step + 1)
        ]        
  set path new-length - ifelse-value (member? self reachable-nodes) [1] [0]
  report path
end 


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

to startup
  
  ask patches [set pcolor white - .15]
end 

to setup
  ;; (for this model to work with NetLogo's new plotting features,
  ;; __clear-all-and-reset-ticks should be replaced with clear-all at
  ;; the beginning of your setup procedure and reset-ticks at the end
  ;; of the procedure.)
  __clear-all-and-reset-ticks 
;  random-seed random-normal 4 1
  set topology-list []
  set density 0
  ct
  ask patches [set pcolor black - .15]
  set-default-shape edges "line"  
  set avg-fitness 0
  set best-fitness 0
  repeat generations * .02 [ 
  create-initial-genetic-info
  sort-global-fitness
  build-ga-network item 0 topology-list
  set best-fitness item compute-factorial num-nodes item 0 topology-list
  plot-density
  ]
end 

to make-nodes
  set-default-shape nodes "circle"
 let colornode 0
;; create nodes and provide them with initial endowment of information
  create-ordered-nodes num-nodes [
    set size .6
     if B&W [
    set color colornode ]
    
    if information-endowment = "deterministic"
      [set own-information value-of-info]
    if information-endowment = "random"  
      [set own-information random-normal value-of-info 1]
    set edgeees []  ;; empty list
      ;; nodes are automatically created with evenly spaced headings,
      ;; so if they just move forward they will form a circle
    fd max-pxcor - 2
    if colornode > 9 [set colornode 0]
    set colornode colornode + .5
     ]
  if information-endowment = "heterogeneous"  
 [   
      
       let lista-valores (list 1 2 3 4 5 6 7 8 10 11 12 13 14 15 16 17 18 
        19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35) 
       ask nodes [set own-information item who lista-valores
        set label (word own-information "c " )
        set label-color black
        set plabel-color red] 
  ]   
end 

to create-initial-genetic-info
  ct
  set fitlist []

  make-nodes
  create-genome

  warshall ;; aca se forman adjacency y transitive
  indirect-information-matrix
  update-transitive-matrix
  
  calculate-profits  
;  show (word basic-genome  " bg")   
    let genome-reduction (list reduce [sentence ?1 ?2] basic-genome)
    set genome-reduction reduce [sentence ?1 ?2] genome-reduction 
    set genome-reduction fput genome-reduction fitlist
    let incoming reduce [sentence ?1 ?2] genome-reduction
    ;;show incoming    
    set topology-list lput incoming topology-list 
end  

to create-genetic-info
  ct

  set genome-list []
  set fitlist []
  make-nodes
  theory-driven
  update-genome ;; here is where seed-genomes become nodes' genome again
  warshall
  indirect-information-matrix
  update-transitive-matrix
  
  calculate-profits  
;  show (word seed-genomes  " sg")
  let genome-reduction (list reduce [sentence ?1 ?2] seed-genomes)
  set genome-reduction reduce [sentence ?1 ?2] seed-genomes

  set genome-reduction fput seed-genomes fitlist
  let incoming reduce [sentence ?1 ?2] genome-reduction
  set topology-list lput incoming topology-list
end  

;;;;;;;;;;;;;;;;;;;;;;
;;; Main Procedure ;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;

to go

    set generation (generation + 1)
    if (generation > generations ) [export stop]
    
    do-best-of-age-plot
    plot-density
    mate-recombine
    mutate
    rebirth
end 
 
 
  
;;;;;;;;;;;;;;;;;;;;;;;
;;; edge Operations ;;;
;;;;;;;;;;;;;;;;;;;;;;;

to build-ga-network [adjacency]
 ;; Nodes randomly are provided with their connection's structure. This is a node procedure.
no-display
;show adjacency 
ask nodes [set genome n-values num-nodes [0]]
 ;; Ahora, copia esos datos y se lo inserta en los genomas de los nodos respectivos (la diagonal principal nunca es usada)
 let y 0
 let f 0
  while [y < (num-nodes - 1)] ;; recorro todos los nodos menos el _ltimo
   [let g y + 1
    while [g < num-nodes] ;; de cada nodo, tengo que llegar al final del genome
     [ask node y [set genome replace-item g genome item f adjacency] 
      set g g + 1
      set f f + 1] 
      set y y + 1
     ]


     
;; se completa la diagonal inferior para todos los nodos, simetrica a la superior
let i 0
let j 0

   while [i < num-nodes ][set j 0
     while [j < num-nodes ][
      if (item j [genome] of node i = 1)
        [ask node j [set genome replace-item i genome 1]
         ]
      set j j + 1]
   set i i + 1]


; let a 0
;while [a < num-nodes]
;   [ask node a [show genome]
;    set a a + 1 ]
    

  set j 0
  set i 0  ;; agregu_ un contador i porque me parece que cuenta a cada nodo su conexi_n pero no recorre todos los nodos.
  
  while [i < num-nodes ]
          [set j 0
           while [j < num-nodes ]
           [if (item j [genome] of node i = 1)
               [make-edge node i node j ]
          set j j + 1]
      set i i + 1
    ]
  plot-accessibility
display
end 

to calculate-profits
;; Nodes procedure 
ask nodes [
 set direct-edgeing-costs 0
 set direct-information own-information
 set indirect-information 0
 set indirect-edgeing-costs 0
 set net-direct-benefit 0
 set net-indirect-benefit 0
 set profits 0
 set edge-cost own-information / ratio-info-edge 
 set genome (replace-item who genome 0)]
;; iterate over the nodes and ask them for their "direct" costs and information benefits
  
let j 0
let k 0
  while [j < num-nodes]
   [set k 0
    while [k < num-nodes]
      [ask node j [if (item k genome = 1)
                   [ifelse decay [set direct-information direct-information + (rate-of-decay * [own-information] of node k)]
                                 [set direct-information direct-information + [own-information] of node k] 
                    set direct-edgeing-costs direct-edgeing-costs + (edge-cost / 2) ]]
             set k k + 1]
     set j j + 1] 
             
set j 0

  while [j < num-nodes]
   [set k 0
    while [k < num-nodes]
     [ask node j [ifelse (item k indirect-info > 0)
                 [ifelse decay [set indirect-information indirect-information + ([direct-information] of node k * (rate-of-decay ^ item k indirect-info))]
                               [set indirect-information indirect-information + [direct-information] of node k] 
                  set indirect-edgeing-costs indirect-edgeing-costs + (item k indirect-info * ( edge-cost / 2 ))]
                  [set indirect-information indirect-information 
                   set indirect-edgeing-costs indirect-edgeing-costs]]       
        set k k + 1]
     set j j + 1]

ask nodes [
      if edge-Cost-Structure = "direct cost direct info"
        [set indirect-information 0  set indirect-edgeing-costs 0]
      if edge-Cost-Structure = "direct cost indirect info"
        [set indirect-edgeing-costs 0]
      if edge-Cost-Structure = "indirect cost direct info"
        [set indirect-information 0]
      if edge-Cost-Structure = "indirect cost indirect info"
        []
  ]  
     

      
 ;; viene del primer ask nodes
;; obtain now the total costs of individuals

 set net-direct-benefit sum [direct-information] of nodes - sum [direct-edgeing-costs] of nodes
 set net-indirect-benefit sum [indirect-information] of nodes - sum [indirect-edgeing-costs] of nodes 
 set profits precision (net-indirect-benefit + net-direct-benefit) 3

 set avg-ind smoothness * avg-ind + (1 - smoothness) * net-indirect-benefit  
 set avg-dir smoothness * avg-dir + (1 - smoothness) * net-direct-benefit 

 let max-links num-nodes * (num-nodes - 1) 
 set density sum-links / max-links

 set fitlist lput profits fitlist
 
 plot-direct-profits
 plot-indirect-profits 
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; edge procedures
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; The algorithm for the following procedure has been borrowed from the 
;; model "Giant Component", in the "Models library".
;; The copyright for this procedure is included at the bottom of this file

  ;; makes a edge from edgeer to edgeee

to make-edge [edgeer edgeee]
  if member? edgeee [edgeees] of edgeer
  [
    user-message (word "There is already a edge from " edgeer " to " edgeee)
    stop
  ]
  create-edges 1
  [
    set origin edgeer
    set destination edgeee
    if show-network-evolution [
    set color [color] of edgeer
    reposition-edge]
    ;set direct-edgeing-costs direct-edgeing-costs + edge-cost
  ]
  
  
    ;; add edgeee to the edgeer's list of edgeees
;  set [edgeees] of edgeer fput edgeee [edgeees] of edgeer
  ask edgeer [ set edgeees fput edgeee edgeees ]
end 

to delete-edge [edgeer edgeee]
  ifelse (member? edgeee [edgeees] of edgeer)
  [
    ask edges [die]
  ]
  [
    user-message (word "There is no edge from " edgeer " to " edgeee)
    stop
  ]
  
  create-edges 1
  [
    set origin edgeer
    set destination edgeee
    if show-network-evolution [
    set color [color] of edgeer
    reposition-edge]
  ]
    ;; add edgeee to the edgeer's list of edgeees
;  set [edgeees] of edgeer fput edgeee [edgeees] of edgeer
  ask edgeer [ set edgeees fput edgeee edgeees ]
end 


;; The algorithm for the following procedure has been borrowed from the 
;; model "Giant Component", in the "Models library".
;; The copyright for this procedure is included at the bottom of this file

  ;; repositions and resizes the edge according to the position of the
  ;; nodes

to reposition-edge  ;; edge procedure
  setxy ([xcor] of origin) ([ycor] of origin)
  set size distance-nowrap destination
    ;; watch out for special case where origin and destination are
    ;; at the same place
  if size != 0
  [
      ;; position edge at midpoint between origin and destination
    set heading towards-nowrap destination
    jump size / 2
  ]
end 

;;;;;;;;;;;;;;;;
;;; Plotting ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;

to plot-accessibility
  let steps accessibility-steps
  let accessibility-by-node-list []

    if accessibility-steps = "Infinity" [set steps num-nodes]

  ;; you cannot sort agents because that creates a list that is not processable as is. 
  let accessibility-list [accessibility steps] of nodes 
  

  let max-accessibility max accessibility-list
  set-current-plot "Accessibility Distribution"
  set-plot-x-range 0 (max-accessibility + 1)  ;; + 1 to make room for the width of the last bar
  histogram accessibility-list
  
 ;set accessibility-by-node-list values-from nodes [accessibility-by-node i steps]
end 

to plot-direct-profits
  auto-plot-on
  set-current-plot "Direct Benefits"
  set-current-plot-pen "net-direct-benefits"  
  plot net-direct-benefit
  set-current-plot-pen "avg-dir"  
  plot avg-dir
end 

to plot-indirect-profits
auto-plot-on

  set-current-plot "Indirect Benefits"
  set-current-plot-pen "net-indirect-benefits"  
  plot net-indirect-benefit
  set-current-plot-pen "avg-ind"  
  plot avg-ind
end  

to do-best-of-age-plot
    set-current-plot "Best-Average-Profit"
    set-current-plot-pen "Moving-Average"
    plot avg-fitness
    set-current-plot-pen "Best"
    plot best-fitness     
end 

to plot-density
auto-plot-on
  set-current-plot "Network Density"
  set-current-plot-pen "density"  
  plot density
end  
;;;;;;;;;;;;;;
;;; Layout ;;;
;;;;;;;;;;;;;;

;; The algorithm for the following procedure has been borrowed from the 
;; model "Giant Component", in the "Models library".
;; The copyright for this procedure is included at the bottom of this file

to layout
  no-display
    ;; these values are arbitrarily chosen to give a good layout
    ;; for typical model settings
  let spring-constant 0.2
  let natural-length 9.0
  let repulsion-constant 1.0

    ;; reset force-x and force-y
  ask nodes
  [
    set force-x 0
    set force-y 0
  ]

    ;; add the forces due to the springs
  without-interruption     ;; process edges one at a time, not concurrently
  [
    ask edges
    [
      let spring-force (spring-constant * (size - natural-length))
        ;; take care of zero sized spring
      ifelse size = 0
      [
        set spring-force spring-constant * natural-length

          ;; we know force but dont know the direction in which to apply it
          ;; make an arbitrary choice of direction ( postive and negative x direction)
        ask origin
        [set force-x force-x + spring-force]
        ask destination
        [set force-x force-x - spring-force]
      ]
      [
        ask origin
        [
          set force-x force-x + spring-force * sin towards-nowrap [destination] of myself
          set force-y force-y + spring-force * cos towards-nowrap [destination] of myself
        ]
        ask destination
        [
          set force-x force-x + spring-force * sin towards-nowrap [origin] of myself
          set force-y force-y + spring-force * cos towards-nowrap [origin] of myself
        ]
      ]
    ]
  ]

    ;; add a force of repulsion between nodes,
    ;; inversely proportional to square of distance
  without-interruption    ;; process nodes one at a time, not concurrently
  [
      ;; exempt edgeless nodes from the force
    let connected-nodes nodes with [not empty? edgeees]
    ask connected-nodes
    [
      ask connected-nodes with [self != myself]
      [
        let angle 0
        let force 0
        ifelse xcor = [xcor] of myself and ycor = [ycor] of myself
          ;; the two nodes are exactly on top of each other.  theoretically
          ;; this shouldn't occur, but in practice, it might because the world
          ;; is bounded and nodes can get forced into the corners.  not clear
          ;; how to handle this, so just apply a small arbitrary force in a
          ;; random direction.
        [
          set angle random-float 360    ;; arbitrary
          set force repulsion-constant  ;; arbitrary
        ]
          ;; normal case where nodes aren't on top of each other
        [
          set angle towards-nowrap myself
          set force repulsion-constant / ((distance-nowrap myself) ^ 2)
        ]
        set force-x force-x - force * sin angle
        set force-y force-y - force * cos angle
      ]
    ]
  ]

    ;; actually move the nodes
  ask nodes
  [
      ;; the current layout scheme has an issue where
      ;; sometimes heavily connected nodes are thrown back and forth.
      ;; to prevent that we cap the movement of nodes
    ifelse force-x > 1
    [ set force-x 1 ]
    [
      if force-x < -1
      [set force-x -1]
    ]
    ifelse force-y > 1
    [ set force-y 1 ]
    [
      if force-y < -1
      [set force-y -1]
    ]
    move (xcor + force-x) (ycor + force-y)
  ]
    ;; reposition all the edges
  ask edges [ reposition-edge ]
    ;; update the display, for smooth animation
  display
end 

  ;; move, but take care not to wrap around edge of world

to move [x y]  ;; buyer procedure
  ifelse x > max-pxcor
    [ set x max-pxcor ]
    [ if x < min-pxcor
      [ set x min-pxcor ] ]
  ifelse y > max-pycor
    [ set y max-pycor ]
    [ if y < (min-pycor + 1)
      [ set y (min-pycor + 1) ] ]
  setxy x y
end 

to drag-and-drop-nodes
    ifelse mouse-down? 
    [ ifelse is-agent? clicked-node 
        [ ask clicked-node [ setxy mouse-xcor mouse-ycor ] ]
        [   ;; no buyer had been clicked
            ;; if there are nodes at the current mouse location, then pick one
          if any? nodes-at mouse-xcor mouse-ycor [  
            set clicked-node one-of nodes-at mouse-xcor mouse-ycor
          ]
        ]
      ask edges [ reposition-edge ] 
    ]
    [   ;; mouse not down
      set clicked-node nobody
    ]    
end 

;; The algorithm for the following procedure has been borrowed from the 
;; model "Preferential Attachment", in the "Models library".
;; The copyright for this procedure is included at the bottom of this file

  ;; resize-nodes, change back and forth from size based on degree to a size of 1

to resize-nodes
  ifelse ( not (any? nodes with [size > 1]) )
  [ ask nodes [ set size sqrt length edgeees] ]
  [ ask nodes [ set size 1 ] ]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Genetic Algorithms Procedures ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to-report compute-factorial [x]
let n 1
let factorial 0
 repeat (x - 1)
  [set factorial factorial + n
   set n n + 1
   ]
 report factorial
end                                                                                                                                                                                                    

to create-genome

;; here is where I must create a random binary string for each node and it must have a zero in 
;; position corresponding to the node because there's no loop condition (no self-connection).
 
 ask nodes [
 set genome []
 set genome n-values num-nodes [0]]
 
 ;; crea el genoma basico de grafo no dirigido (matriz triangular superior)
 set basic-genome []
 set basic-genome n-values compute-factorial num-nodes  [random 2]
 
 ;; Ahora, copia esos datos y se lo inserta en los genomas de los nodos respectivos (la diagonal principal nunca es usada)
 let y 0
 let g 1
  while [y < (num-nodes - 1)] ;; recorro todos los nodos menos el _ltimo
   [set g y + 1
    while [g < num-nodes] ;; de cada nodo, tengo que llegar al final del genome
     [ask node y [set genome replace-item g genome item y basic-genome] 
      set g g + 1
      ] 
      set y y + 1
     ]
     
;; se completa la diagonal inferior para todos los nodos, simetrica a la superior
let i 0
let j 0

   while [i < num-nodes ][set j 0
     while [j < num-nodes ][
      if [item j genome] of node i = 1
        [ask node j [set genome replace-item i genome 1]
         ]
      set j j + 1]
   set i i + 1]

;show basic-genome
;let a 0
;while [a < num-nodes]
;   [ask node a [show genome]
;    set a a + 1 ]
end 

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

to warshall 
set sum-links 0
;; It creates the reachability-matrix by adding individual's node genome
 set adjacency-matrix []
 set transitive-matrix []

;; this is the adjancency matrix
 let p 0
    while [p < num-nodes]
     [set adjacency-matrix lput [genome] of node p adjacency-matrix 
      set sum-links sum-links + sum [genome] of node p
      set p p + 1]
   
;diag-zero adjacency-matrix      

 ;;; Warshall's algorithm
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 let i 0
 let j 0
 let k 0

;; Get a copy of the transitive closure matrix
set transitive-matrix adjacency-matrix 
let track 1
 while [i < num-nodes] 
    [ set j 0
     while [j < num-nodes]
      [if (item j item i transitive-matrix = 1)
        [set k 0 set track 1
         while [k < num-nodes]
          [ if (item j item k transitive-matrix = 1)
           [set transitive-matrix (replace-item i transitive-matrix (
            replace-item k (item i transitive-matrix) track ))]
            set track track + 1
           set k k + 1]]
       set j j + 1]
    set i i + 1]
;show (word transitive-matrix "a")
;; Finally we got the transitive closure matrix for the original adjacency-matrix 
end 

to indirect-information-matrix

let prev-indirect-info n-values num-nodes [n-values num-nodes [0]] ;; a matrix of num-nodes of zeroes is created
ask nodes [set indirect-info []]
  let r 0
  let s 0

while [r < num-nodes]
   [set s 0
    while [s < num-nodes]
        [ 
         set prev-indirect-info (replace-item r prev-indirect-info
                    (replace-item s (item r prev-indirect-info) 
                    (item s item r transitive-matrix - item s item r adjacency-matrix))) ;; acabo de agregar valor absoluto
         set s s + 1]
        set r r + 1]

let i 0
 while [i < num-nodes]
       [ ask node i [set indirect-info item i prev-indirect-info]
          set i i + 1 ]       
end 

to update-transitive-matrix
;; Back transformation, return reachability-matrix to reachability-matrix in the original
;; format of genome 
set transitive-matrix []
let p 0
    while [p < num-nodes]
     [
       set transitive-matrix lput [indirect-info] of node p transitive-matrix  
       set p p + 1
     ]

;show (word transitive-matrix "b")
end 

to sort-global-fitness
set topology-list remove-duplicates topology-list
set topology-list sort-by [ item compute-factorial num-nodes ?1 > item compute-factorial num-nodes ?2] topology-list
end 

to mate-recombine

;let scd compute-factorial num-nodes / 2

set best-fitness item compute-factorial num-nodes item 0 topology-list 
set avg-fitness smoothness * avg-fitness + (1 - smoothness) * best-fitness 

;; Ac_ tengo que elegir entre cual configuraci_n, provista por genome, me da mayor pago, provista por fitness, y seleccionar la mejor. 
;; tengo entonces que ver como formo la matriz de adyacencia de la que deriva la formaci_n original y la nueva que se utilizar_
;; con el algoritmo gen_tico.



    if Selection = "Elitism"  [elitism
                               set seed-genomes item 0 winner-list]
    if Selection = "Roulette" [wheel-roulette
                              let chosen-generation item random-float length ranking ranking
                              let chosen-topology position chosen-generation ranking 
                              set seed-genomes item chosen-topology topology-list ]
    if Selection = "Tournament" [tournament
                              set seed-genomes item 0 winner-list]


 ; will only allow mating between chosen ones of previous generation (not their offspring)
  
  
  make-mix-genes                               ;recombine genomes of those who mate
  let o 0 
  
  while [o < (compute-factorial num-nodes)]
  [
   set seed-genomes (replace-item o mix-genes item o seed-genomes)
   set o o + 1
  ]
end 

to wheel-roulette
let i 0
set sum-fitness 0
set ranking []

while [i < min (list (generations * .01) length topology-list) ]
  [
  set sum-fitness sum-fitness + item compute-factorial num-nodes item i topology-list 
  set i i + 1
  ]
set i 0  
while [i < min (list (generations * .01) length topology-list) ]
  [
  set ranking lput ((item compute-factorial num-nodes item i topology-list) / sum-fitness) ranking 
  set i i + 1
  ]
end  

to tournament

let draftlist topology-list
set winner-list []
set draftlist shuffle topology-list
set winner-list n-of (1 + random(length draftlist / 2)) draftlist

set winner-list sort-by [ item (compute-factorial num-nodes) ?1 > item (compute-factorial num-nodes) ?2] winner-list 
end 

to elitism

let draftlist topology-list
set winner-list []
set winner-list sublist draftlist 0 (1 + random (length draftlist - 1))
end 

to driven-theory

set empty-topology n-values compute-factorial num-nodes [0]
set complete-topology n-values compute-factorial num-nodes [1]
;set complete-topology diag-zero complete-topology 
end 

to make-mix-genes
;; trabajan con seed-genomes, toman un _tem al azar y crean el marido. Igualan a la esposa con el marido
;; si el item 0 de seed-genomes = item 1 de seed-genomes no pasa nada, pero si no son iguales entonces
;; igualo ambos 
 let k 0
 let i random compute-factorial ( num-nodes - 1)
 let v compute-factorial num-nodes - i
 
 
  set mix-genes []
  let husband []
  let wife []
  
  let chosen random-float 1
  let swap false
    while [k < i][
     ifelse chosen < .5 [ set swap true
     if Selection = "Elitism"  [ set husband lput item k seed-genomes husband]
     if Selection = "Roulette" [ set husband lput item k seed-genomes husband]
     if Selection = "Tournament" [ set husband lput item k item 0 winner-list husband] ]
     [
      if Selection = "Elitism"  [set wife lput item k seed-genomes wife]
      if Selection = "Roulette" [set wife lput item k seed-genomes wife] 
      if Selection = "Tournament" [set wife lput item k item 0 winner-list wife] 
     ]
      ;assigns random genome to husband
     set k k + 1
     ]
;; consultar este procedimiento con Ignacio: el esposo es mitad del item k de seed-genomes en elitism...?
  while [k < v][
  ifelse swap = true [
  ;set wife lput item k item random generation topology-list wife
    if Selection = "Elitism"  [set wife lput item k item random length winner-list winner-list wife]
    if Selection = "Roulette" [set wife lput item k item random length topology-list topology-list wife] 
    if Selection = "Tournament" [set wife lput item k item 0 winner-list wife] ]
    [
     if Selection = "Elitism"  [set husband lput item k item random length winner-list winner-list husband]
     if Selection = "Roulette" [set husband lput item k item random length topology-list topology-list husband]
     if Selection = "Tournament" [set husband lput item k item 0 winner-list husband] 
    ]
   ;other half goes to wife
  set k k + 1
  ]
  
   while [k < compute-factorial num-nodes][
     ;ifelse chosen < .5 [ set swap true
   
   ifelse swap = true [
     if Selection = "Elitism"  [ set husband lput item k seed-genomes husband]
     if Selection = "Roulette" [ set husband lput item k seed-genomes husband]
     if Selection = "Tournament" [ set husband lput item k item 0 winner-list husband] ]
     [
      if Selection = "Elitism"  [set wife lput item k seed-genomes wife]
      if Selection = "Roulette" [set wife lput item k seed-genomes wife] 
      if Selection = "Tournament" [set wife lput item k item 0 winner-list wife] 
     ]
      ;assigns random genome to husband
     set k k + 1
     ]
   

let wh []
set wh lput wife wh
set wh lput husband wh
let mix-previous reduce [sentence ?1 ?2] wh 
set mix-genes reduce [sentence ?1 ?2] mix-previous
end 

to mutate
;; Here is where a mask covering the zeroes in diagonal must be added.    

   let genome-m 0
       while [genome-m < length seed-genomes] [ ; scan all genes
           if (random-float 1000 < mutation-rate * 1000)  
           ; change bit if mutation rate threshold is met
           [ let switch item genome-m seed-genomes
           ifelse (switch = 1)
           [ set seed-genomes (replace-item genome-m seed-genomes 0 ) ]
           [ set seed-genomes (replace-item genome-m seed-genomes 1 ) ]
           ]
   set genome-m genome-m + 1 ; moves to next genome
    ] 
;set seed-genomes diag-zero seed-genomes
end 

to rebirth
   
   ask patches [set pcolor black - .15]
   set-default-shape edges "line"
   create-genetic-info
   sort-global-fitness
   if length topology-list > 50 [set topology-list butlast topology-list]
   set topology-list remove-duplicates topology-list
   build-ga-network item 0 topology-list
end 

to update-genome 
 
 ask nodes [set genome n-values num-nodes [0] ]
; show seed-genomes
 ;; Ahora, copia esos datos y se lo inserta en los genomas de los nodos respectivos (la diagonal principal nunca es usada)
  
  let j 0
  let q 0
  while [j < (num-nodes - 1)][ let i j + 1
   while [i < num-nodes]
    [ask node j [set genome (replace-item i genome item q seed-genomes)]
       set q q + 1
       set i i + 1 ]
     set j j + 1]
    

;; se completa la diagonal inferior para todos los nodos, simetrica a la superior
let i 0
set j 0

   while [i < num-nodes ][set j 0
     while [j < num-nodes ][
      if [item j genome] of node i = 1
        [ask node j [set genome replace-item i genome 1]
         ]
      set j j + 1]
   set i i + 1]

;let a 0
;while [a < num-nodes]
;   [ask node a [show genome]
;    set a a + 1 ]
; 
end 

to theory-driven
if theory-driven? [driven-theory
let chosen random-float 1
ifelse chosen < .5 [
  set seed-genomes empty-topology]
 [set seed-genomes complete-topology  ]
 
 set theory-driven? false]
end 


;to-report diag-zero [matrix]
;;; zero diagonal mask  
;;; esta mal, hace cualquier cosa...
; ;let s matrix
; ;let p length s
; ;show s
; let i 1
; let j num-nodes
; while [j < (num-nodes * num-nodes)]
;       [ set matrix  replace-item (i + j) matrix  0
;         set i i + 1
;         set j j + num-nodes
;        ]   
; set matrix  replace-item 0 matrix  0        
; set matrix  replace-item (num-nodes * num-nodes - 1) matrix  0  
; ;show s
; report matrix 
;end

;;;;;;;;;;;;;;;;;;;;;
;;; Export Outcomes ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;

to export
let i 0
file-delete "GA_1.txt"
file-open "GA_1.txt"

while [i < num-nodes][
  ask node i [print (word "node "  i  " " genome)]
  set i i + 1 ]

export-output "GA_1.txt"
file-close 
export-view (word edge-Cost-Structure "-" generations "-"  "-" ".png") 
export-plot "Accessibility Distribution" "Access.csv"
end