Multiplying large blocks of data?
what would be a good way of multiplying a block of numbers 1 - 1,000,000 by 2?
test: [1 2 3...1000000]
test2: []
foreach num test [append test2 num * 2]
that seems to do the trick, but I'm sure there must be another way.
posted by: Andrew 17-Jun-2017/0:19:38-7:00
You can do this:
t: [1 2 3 4 5 6]
repeat x length? t [t/(x): t/(x) * 2]
posted by: Nick 17-Jun-2017/1:17:46-7:00
and BTW, to test it with an actually large block:
t: copy [] insert/dup t 1 1000000
repeat x length? t [t/(x): t/(x) * 2]
posted by: Nick 17-Jun-2017/1:21:09-7:00
and also BTW, to create a list of numbers 1-10million, the first option below is much faster:
t: copy [] repeat i 10000000 [insert tail t i]
t: copy [] repeat i 10000000 [append t i]
posted by: Nick 17-Jun-2017/1:27:21-7:00
Why not use `map-each`, which is designed for it:
t: [1 2 3 4 5 6]
map-each i t [i * 2]
Well, the times are a bit different:
0:00:11 map-each
0:00:06 foreach Andrew
0:00:04 repeat Nick
posted by: Geekyi 18-Jun-2017/8:43:48-7:00
Yes, and for 10 million+ values, for example, the delay makes a dramatic difference (seconds rather than minutes).
posted by: Nick 18-Jun-2017/9:55:56-7:00
This worked a bit faster on my PC
t: copy [] insert/dup t 1 1000000
i: 1 until [t/:i: t/:i * 2 tail? t: next t]
posted by: Endo 19-Jun-2017/5:11:04-7:00
Interesting, running on a little Windows 8 tablet with Z3735G 1.33 GHz CPU and 1 GB RAM (w/ Rebol 2.7.8.3.1), my results are the opposite in every case:
>> t: copy [] repeat i 10000000 [insert tail t i]
== []
>> delta-time [i: 1 until [t/:i: t/:i * 2 tail? t: next t]]
== 0:00:21.236
>> t: copy [] repeat i 10000000 [insert tail t i]
== []
>> delta-time [repeat x length? t [t/(x): t/(x) * 2]]
== 0:00:16.228
>> t: copy [] insert/dup t 1 10000000
== []
>> delta-time [i: 1 until [t/:i: t/:i * 2 tail? t: next t]]
== 0:00:22.194
>> t: copy [] insert/dup t 1 10000000
== []
>> delta-time [repeat x length? t [t/(x): t/(x) * 2]]
== 0:00:15.447
What system are you running Endo? I'm really curious about the difference in performance.
posted by: Nick 19-Jun-2017/8:41:57-7:00
Here's the cleaned up copy of the tests - curious to hear results on other platforms:
t: copy [] repeat i 10000000 [insert tail t i]
delta-time [i: 1 until [t/:i: t/:i * 2 tail? t: next t]]
t: copy [] repeat i 10000000 [insert tail t i]
delta-time [repeat x length? t [t/(x): t/(x) * 2]]
t: copy [] insert/dup t 1 10000000
delta-time [i: 1 until [t/:i: t/:i * 2 tail? t: next t]]
t: copy [] insert/dup t 1 10000000
delta-time [repeat x length? t [t/(x): t/(x) * 2]]
posted by: Nick 19-Jun-2017/8:51:20-7:00
t1 14.433255 14.375567 14.562163
t2 10.988527 10.948129 10.986415
t3 14.513004 14.739353 14.632172
t4 11.097424 10.935371 10.952677
linux 3.14.20 (i686) Inspiron 1501
tahrpup 6.0 (Puppy Linux)
Mobile AMD Sempron 3500+ 800 mhz
Memory:
Total: 14166616 kB
Free: 714000 kB
Available: 101500 kB
posted by: Howard 19-Jun-2017/19:16:53-7:00
t1 18.689 18.720 18.844
t2 13.876 13.813 13.819
t3 18.454 18.532 18.610
t4 13.829 13.844 13.860
Windows 8 64bit
Ausus S200E
Celeron 847 1.1 Ghz
2 GB memory, 1.89 GB usable
hmnnn....
posted by: Howard 19-Jun-2017/23:13:13-7:00
>> t: copy [] repeat i 10000000 [insert tail t i]
== []
>> delta-time [i: 1 until [t/:i: t/:i * 2 tail? t: next t]]
== 0:00:10.66
>> t: copy [] repeat i 10000000 [insert tail t i]
== []
>> delta-time [repeat x length? t [t/(x): t/(x) * 2]]
== 0:00:08.004
>> t: copy [] insert/dup t 1 10000000
== []
>> delta-time [i: 1 until [t/:i: t/:i * 2 tail? t: next t]]
== 0:00:10.386
>> t: copy [] insert/dup t 1 10000000
== []
>> delta-time [repeat x length? t [t/(x): t/(x) * 2]]
== 0:00:08.03
posted by: Nick 20-Jun-2017/23:11:17-7:00
My friend had an assignment in college for a program called MatLab. He mentioned that MatLab can multiply arrays together, like [2 3 4 5 6] * [3 4 5 6 7] to make one which is [6 12 20 30 42].
What would be an easy way to do this?
R E B O L []
lol1: [2 3 4 5 6]
lol2: [3 4 5 6 7]
lol3: []
foreach lol lol1 [append lol3 (lol * first lol2) remove lol2]
posted by: Andrew 22-Jun-2017/19:15:21-7:00
repeat i length? lol1 [insert tail lol3 lol1/:i * lol2/:i]
posted by: Nick 23-Jun-2017/1:23:57-7:00
If you'll perform this operation often, create a function and put it in your rebol.r file:
multiply-blocks: func [bl1 bl2] [
bl3: copy []
repeat i length? bl1 [insert tail bl3 bl1/:i * bl2/:i]
bl3
]
multiply-blocks [2 3 4 5 6] [3 4 5 6 7]
lol1: [2 3 4 5 6]
lol2: [3 4 5 6 7]
multiply-blocks lol1 lol2
You can choose how to handle blocks of different length, how to handle a arbitrary number of blocks, etc.:
multiply-all: func [bl] [
result: copy []
lens: copy []
foreach b bl [append lens length? b]
len: first minimum-of lens
repeat i len [
total: 1
foreach b bl [total: total * b/:i]
append result total
]
result
]
multiply-all [ [1 2 3 4 5 6] [2 3 4 5] [3 4 5 6 7] ]
posted by: Nick 23-Jun-2017/10:36:41-7:00
Here's the function above using 'map-each to find the shortest input block:
multiply-all: func [bl] [
result: copy []
repeat i first minimum-of map-each b bl [length? b] [
total: 1
foreach b bl [total: total * b/:i]
append result total
]
]
multiply-all [[1 2 3 4 5 6][2 3 4 5][3 4 5 6 7]]
posted by: Nick 23-Jun-2017/10:59:03-7:00
(try that function with any number of blocks, each containing any arbitrary number of values)
posted by: Nick 23-Jun-2017/11:04:50-7:00
Could you explain what lol1/:i means, or give me a link to an explanation ?
posted by: Andrew 23-Jun-2017/16:48:45-7:00
> lol1/:i
It's an equivalent to pick lol1 i.
In addition, you can use the notation for assigning values too. Example with different word names:
blk: copy [a b c d e f]
ind: 4
blk/:ind ;; equivalent to pick blk ind
== d
blk/:ind: 88 ;; equivalent to poke blk ind 88
blk
== [a b c 88 e f]
posted by: Sunanda 23-Jun-2017/17:00:57-7:00
Thank you so much !
posted by: Andrew 23-Jun-2017/17:13:41-7:00
Why do you do blk: copy [a b c d e f] instead of blk: [a b c d e f]?
posted by: Andrew 23-Jun-2017/17:32:30-7:00
'Copy ensures that any previous values in the block are erased.
posted by: Nick 24-Jun-2017/6:36:11-7:00
|