I have a list of 10 probabilities that I want to transform to line segments so I can perform roulette wheel selection. How can I transform to line segments?
Probability list:
[0.17 0.15 0.14 0.14 0.11 0.1 0.06 0.06 0.04 0.03]
When transformed into line segments should be:
[0.17 0.32 0.46 0.60 0.71 0.81 0.87 0.93 0.97 1.0]
Right now this is my code:
to calculate-s
let i 1 ;; previously added a 0 to list using set p-list fput 0 p-list
while [i < 11] [
ask turtles [
if [p] of self = item i p-list [
let s (p + item (i - 1) p-list)
]
]
set i (i + 1)
]
end
But of course it just sums the current probability and the previous one so I get:
[0.17 0.32 0.29 0.28 etc]
I'm not sure exactly what you mean by line segments, but if you just want a self-contained block that creates a list where
newlist[i] = (oldlist[i] + (newlist[i - 1]))
You can use foreach to step through the old list and generate a new list of summed values, as below.
to make-segments
let oldlist [0.17 0.15 0.14 0.14 0.11 0.1 0.06 0.06 0.04 0.03]
let newlist []
let n 0
foreach oldlist [
[x]->
ifelse n < 1 [ ;;; if index is 0 you can't index 0 -1, so just use item 0
set newlist lput item 0 oldlist newlist
]
[ ;;; else, add the item n from the old list to the
;;; previous item in the new list.
set newlist lput (precision (item n oldlist + item (n - 1) newlist) 2) newlist
]
set n n + 1
]
print newlist
end
Related
I have a vector 'original' with 10 digits. Now I want to create vector 'adapted' based on 'original'. 'adapted' is supposed to take n random values that are larger than 0 from 'original' in the same position and fill up the rest with 0s, e.g.:
original = [2 3 6 2 0 5 7 2 4 8]
adapted = [2 0 0 0 0 5 0 2 0 0]
to go
let n 3
let vector-dimension 10
let original []
repeat vector-dimension
[set original lput random 10 original]
print original
let adapted []
while [sum (map [ [v1] -> ifelse-value (v1 > 0) [1] [0] ] (adapted)) != n]
[set adapted (map [ [v1] -> ifelse-value ( (vector-dimension / n) * (100 / vector-dimension) > random-float 100) [v1] [0] ] (original)) ]
print adapted
end
This Code works but is slow. How can I do it faster?
How about:
to-report report-rand-n [ base n ]
let indices ( range 0 (length base))
let subset n-of n indices
let out ( map [ [ i v ] -> ifelse-value ( member? i subset ) [v] [0] ] indices base)
report out
end
This reporter makes a list of indices (0 through the length of the base passed), then randomly selects n number of those indices to pass to ifelse-value to return either the original value in base (if i is one of the selected indices) or 0.
Testing:
to test
let original [2 3 6 2 0 5 7 2 4 8]
print report-rand-n original 3
print report-rand-n original 3
print report-rand-n original 5
print report-rand-n original 5
end
observer> test
[2 0 6 0 0 0 0 0 4 0]
[2 0 0 0 0 0 0 2 0 8]
[2 0 0 0 0 5 0 2 4 8]
[0 0 6 2 0 5 0 0 0 8]
Edit:
to test
let original [2 3 6 2 0 5 7 2 4 8]
print word "testing: " original
print report-rand-n original 3
let few-digits [ 0 0 0 1 0 0 0 ]
print word "testing: " few-digits
print report-rand-n few-digits 3
print ""
end
to-report report-rand-n [ base n ]
; create list of indices
let indices ( range 0 (length base))
; To address point 1) in your comment:
; keep only indices that correspond to a value > 0 in base
let indices-over-zero filter [ i -> item i base > 0 ] indices
; To address point 2 in your comment:
; If the length of indices over zero is less than n, replace n
; with the length of indices over zero
if length indices-over-zero < n [
set n length indices-over-zero
]
let subset n-of n indices-over-zero
let out ( map [ [ i v ] -> ifelse-value ( member? i subset ) [v] [0] ] indices base)
report out
end
I try to figure out, how to create an output that has an equal distribution on the random sample. Based on the code snippet below, the function creates three random numbers for three items in a list. This values gets than compared to each other, and the maximal value of them, gets count. However I am trying to figuring out how to control the randomness by a probability for example 50% (50) 25% (25) 25% (25) N=100.
to numberGenerator
let i 0
set counter_red 0
set counter_blue 0
set counter_green 0
while [i < 100] [
let numberS_red1 random-float 1
let numberS_blue1 random-float 1
let numberS_green1 random-float 1
let usedcolors [red blue green]
let OPstrength1 ( list numberS_red1 numberS_blue1 numberS_green1)
let strategies (map list usedcolors OPstrength1)
print strategies
if (numberS_red1 > numberS_blue1) and (numberS_red1 > numberS_green1)
[set counter_red counter_red + 1]
if (numberS_blue1 > numberS_red1) and (numberS_blue1 > numberS_green1)
[set counter_blue counter_blue + 1]
if (numberS_green1 > numberS_red1) and (numberS_green1 > numberS_blue1)
[set counter_green counter_green + 1]
set i i + 1
]
print counter_red
print counter_blue
print counter_green
end
counter_red = 26
counter_blue = 36
counter_green = 38
you can implement a new function using the netlogo random-normal command which assigns a color. Documentation for the function is at link
I'm working with the matrix extension in NetLogo. I want to be able to modify specific elements of the matrix if they equal some number.
For instance if the value is 0.95 I want to run random 2 on it so it comes out as a 1 or a 0. And if it's a 1.75 it comes out as a 1 or a 2 with random (3 - 1) + 1
This would change my matrix m from this:
let m matrix:from-row-list [[1 0.95 0.95] [2 1 1.75] [1 2 1] ]
to this:
[[1 1 0] [.05 1 2] [.05 .25 1] ]
Thanks
I'm not sure if I understand your updated matrix example- for example, why does the 2 in the second row become 0.05 in the output? I'm assuming you have some other rules for dealing with those numbers. Anyway, I think you can use matrix:map to accomplish what you're after- you may just have to set up the rules in your anonymous reporter to reflect what you're after. Here is an example using the rules you supplied for values of 0.95 and 1.75:
extensions [ matrix ]
to matrix-manipulation
let m matrix:from-row-list [[1 0.95 0.95] [2 1 1.75] [1 2 1] ]
let m2 matrix:map [ i -> val-change i ] m
print matrix:pretty-print-text m2
end
to-report val-change [ val ]
if val = 0.95 [
report random 2
]
if val = 1.75 [
report 1 + random 2
]
report val
end
Output becomes:
[[ 1 0 1 ]
[ 2 1 2 ]
[ 1 2 1 ]]
How can I find the first zero's index which is followed by 5 zeros in a list? In case no such zero exists return -1.
Netlogo only returns the first element found in a list with position which makes it difficult/cumbersome.
In the question you say you want -1 back if it isn't found, but that doesn't match the behavior of NetLogo's own position primitive, which returns false if the item isn't found. I'd suggest sticking with the usual NetLogo convention for this.
Recursive solution:
to-report position-of-six-zeros [xs]
if length xs < 6
[ report false ]
if sublist xs 0 6 = [0 0 0 0 0 0]
[ report 0 ]
let recurse position-of-six-zeros butfirst xs
if not is-number? recurse
[ report recurse ]
report 1 + recurse
end
Sample runs:
observer> show position-of-six-zeros [0 0 0 0 0]
observer: false
observer> show position-of-six-zeros [0 0 0 0 0 0 ]
observer: 0
observer> show position-of-six-zeros [1 2 3 0 0 0 0 0 0 4 5 6]
observer: 3
observer> show position-of-six-zeros [1 2 3 0 0 0 0 0 4 5 6]
observer: false
I found a possible solution. Maybe there are smarter ways to achieve the same, but at least this approach should work.
You define a list, the length of the sequence you want to look at and the number, which the sequence should have. Then you call the reporter function (check-sequence) with that information.
The reporter function then uses a while loop. It takes the next length-of-sequence elements and filters this sublist by the specified number-of-interest. If the length of this filtered list is the same as the specified length-of-sequence the function will store the actual position on the whole list (i). If not, the first element of the list will be dropped and the loop runs again. If there are not enough elements left in the list, the loop will stop and set the reporter to -1. Otherwise it will report the starting position of the sequence.
to go
let my-list (list 0 1 2 3 0 0 0 8 9 8)
let length-of-sequence 4
let number-of-interest 0
print check-sequence my-list length-of-sequence number-of-interest
end
to-report check-sequence [a-list sequence number]
let i 0
let stopper 0
let reporter 0
while [stopper = 0]
[
let filtered_sublist filter [? = number] (sublist a-list 0 sequence)
if (length filtered_sublist = sequence)
[
set reporter i
set stopper 1
]
set a-list but-first a-list
set i (i + 1)
if (length a-list < sequence)
[
set stopper 2
]
]
ifelse (stopper = 2)
[ report -1 ]
[ report reporter ]
end
I tried posting this to the NetLogo user group on Yahoo but wasn't successful in getting the post accepted. So I'm trying here.
NetLogo can plot histograms. Is there any way to get access to the histogram data, i.e., the data generated for the histogram plot? Thanks.
Happy Holidays, Russ!
I don't think it's possible to get the values. Though if you wanted to implement your own histogram for data, you could use something like:
to-report calc-histogram [ aList numBars aMaxValue ]
let minValue min aList
let interval (aMaxValue - minValue) / numBars
let hist []
foreach n-values numBars [?] [
let lowerBound minValue + (? * interval)
let upperBound lowerBound + interval
let x (lowerBound + upperBound) / 2
let y length filter [? >= lowerBound and ? < upperBound] aList
set hist lput (list x y ) hist
]
report hist
end
example usage:
observer> calc-histogram [0 1 18 2 3 4 5 6 7 7 7 9 10 7 15 7 17 18 19 ] 5 20
observer: [[2 4] [6 8] [10 2] [14 1] [18 4]]