I need to calculate a connection value between myself and all of my nearPersons which uses among others the trust value of the link. However, getting the trust values ​​of all links and using these in the computation slows down the running time. I did not succeed to find another way to do it more efficiently. Any suggestions would be highly appreciated!

breed [persons person]
undirected-link-breed [connections connection]
connections-own [trust]

persons-own 
[
  nearPersons
  familiarity
]
 
to setup
  clear-all
  setupPersons
  setupConnections
  updateConnections
  reset-ticks
end

setupPersons
  create-persons 1000
  [
    set color black
    set grouped false 
    setxy random-xcor random-ycor
  ]
end

to setupConnections
  ask persons [create-connections-with other persons]
  ask connections [ set trust 0.4]
end

to updateConnections
  while [(count persons with [grouped = false] / 1000) > 5]
  [
    let highlyTrusted n-of (2 + random 9) (persons with [grouped = false])
    ask highlyTrusted
    [
      ask my-out-connections with [member? other-end highlyTrusted] [set trust 0.6]
      set grouped true
    ]
  ]
end

to go
  getNearPersons
  calculateConnection
  forward 1
end

to getNearPersons
  ask persons [ set nearPersons other persons in-cone 3 360 ]
end

to calculateConnection
  ask persons with [nearPersons != nobody]
  [
    ask nearPersons
    [
      let degreeOfTrust [trust] of in-connection-from myself
     ]
   ]
end

2

Here is the model using agents of trust rather than links. I think that it will give you identical results, as long as there are only those two trust levels. I made a few other changes in the code – in particular your original while The statement would never run as it was written (the quotient was always 1). Most are simply matters of style. Let me know if this is not what you need. Still not a speed demon, about 5 seconds per tick with 1000 persons, but a lot faster than the link version. Note that nPersons is a global so that I could play around with it.

Charles

globals [nPersons]

breed [persons person]

persons-own
[
  nearPersons
  Trusted
  unTrusted
  familiarity
  grouped
]

to setup
  clear-all
  set nPersons 1000
  ask patches [ set pcolor gray ]
  setupPersons
  updateConnections
  reset-ticks
end

to setupPersons
  create-persons nPersons
  [
    set color black
    set grouped false
    setxy random-xcor random-ycor
  ]
  ask persons [
    set Trusted no-turtles
    set unTrusted persons
    set familiarity 1
  ]
end

to updateConnections
  while [(count persons with [grouped = false] / nPersons) > 0.2]
  [
    let highlyTrusted n-of (2 + random 9) (persons)  
    ; so persons can be in more than one trust group and treat all trust groups equally?
    ask highlyTrusted
    [
      set Trusted other highlyTrusted
      set grouped true
    ]
  ]
end

to go
  ask persons [ getNearPersons ]
  calculateConnection
  ask persons [ forward 1 ]
  tick
end

to getNearPersons
  ask persons [ set nearPersons other persons in-radius 3 ]
end

to calculateConnection
  ask persons with [any? nearPersons]
  [
    let affiliation []
    ask nearPersons
    [
      let degreeOfTrust ifelse-value (member? myself Trusted) [0.6] [0.4]
;      let degreeOfTrust [trust] of in-connection-from myself ;;this line causes netlogo to run very slowly
      set affiliation lput (degreeOfTrust * familiarity) affiliation 
     ]
   ]
end

4

I had to make a few modifications of your code to make it run, I’ve included it below. But I believe the real problem is just the scale of what you are doing. With 1000 persons, there are approximately half a million links that you are repeatedly polling, and given the size of your world, the number of nearPersons for each person is likely quite large. Do you really need 1000 persons in your model, and/or do you really need every person to be connected to every other person? The number of links goes up exponentially with the number of persons.

breed [persons person]
undirected-link-breed [connections connection]
connections-own [trust]

persons-own
[
  nearPersons
  familiarity
  grouped
]

to setup
  clear-all
  setupPersons
  show "persons setup"
  setupConnections
  show "connections setup"
  updateConnections
  show "connections updated"
  reset-ticks
end

to setupPersons
  create-persons nPersons
  [
    set color black
    set grouped false
    setxy random-xcor random-ycor
  ]
end

to setupConnections
  ask persons [create-connections-with other persons]
  ask connections [ set trust 0.4]
end

to updateConnections
  while [(count persons with [grouped = false] / 1000) > 5]
  [
    let highlyTrusted n-of (2 + random 9) (persons)
    ask highlyTrusted
    [
      ask my-out-connections with [member? other-end highlyTrusted] [set trust 0.6]
      set grouped true
    ]
  ]
end

to go
  ask persons [ getNearPersons ]
  show mean [count nearPersons] of persons
  ask persons [ calculateConnection ]
  show "got Connections"
  ask persons [ forward 1 ]
  tick
end

to getNearPersons
  ask persons [ set nearPersons other persons in-cone 3 360 ]
end

to calculateConnection
  ask persons with [nearPersons != nobody]
  [
    let affiliation []
    let idx 0
    ask nearPersons
    [
      let degreeOfTrust [trust] of in-connection-from myself ;;this line causes netlogo to run very slowly
      set affiliation insert-item idx affiliation (degreeOfTrust * familiarity)
      set idx idx + 1
     ]
   ]
end

3

Not the answer you’re looking for? Browse other questions tagged performance or ask your own question.