I think you are right. I see a persistent but small (<5%) difference in
my timings. Much less than I expected. The m&v version does
reinterpret (u^:n) for every atom, but it takes a fast path and does not
have to allocate memory.
Henry Rich
On 8/17/2020 11:56 AM, 'robert therriault' via Programming wrote:
Thanks Henry,
I have increased argument sizes and defined using tacit. I am still not seeing
results that suggest the differences in the two approaches. Feel free to ignore
if I am just running down a rabbit hole, but if it is useful here are my
results.
JVERSION
Engine: j902/j64avx2/darwin
Beta-e: commercial/2020-08-14T13:00:52
Library: 9.02.05
Qt IDE: 1.8.7/5.12.7(5.12.7)
Platform: Darwin 64
Installer: J902 install
InstallPath: /users/bobtherriault/j902
Contact: www.jsoftware.com
operand =. 2 2 2 $ 3 2 2 3 2 3 3 2 NB. original arguments
bitmask =. 2 2 2 $ 1 0 0 1 0 1 1 0
roger =: 0&(] >:)"0 NB. tacit definitions
henry =: >:@]^:["0
bitmask roger operand
4 2
2 4
2 4
4 2
bitmask henry operand
4 2
2 4
2 4
4 2
10 timespacex 'bitmask roger operand'
7e_7 1792
10 timespacex 'bitmask henry operand'
8e_7 1792
operand1 =. 200 200 200 $ 3 2 2 3 2 3 3 2 NB. larger arguments
bitmask1 =. 200 200 200 $ 1 0 0 1 0 1 1 0
10 timespacex 'bitmask1 roger operand1'
0.342831 6.71104e7
10 timespacex 'bitmask1 henry operand1'
0.332431 6.71104e7
operand2 =. 2000 2000 200 $ 3 2 2 3 2 3 3 2 NB. even larger arguments
bitmask2 =. 2000 2000 200 $ 1 0 0 1 0 1 1 0
timespacex 'bitmask2 roger operand2' NB. run only once because of
time required to calculate
36.86 8.58994e9
timespacex 'bitmask2 henry operand2'
35.5014 8.58994e9
Cheers, bob
On Aug 17, 2020, at 07:54, Henry Rich <henryhr...@gmail.com> wrote:
With arguments that small, most of the time is spent in lexing and parsing. To
test the time of execution, you need arguments long enough that the execution
dominates. Or, you can make a tacit verb that has done the parsing in advance.
To get serious measurements you need to delay the sampling until the process
has been CPU-bound long enough for the OS to change its scheduling mode from
interactive to batch.
Henry Rich
On 8/17/2020 10:45 AM, 'robert therriault' via Programming wrote:
Thanks Henry,
I woke up this morning realizing that the argument to & could be any value and
that cleared up a lot of my fuzziness on what was going on. Thank you to Pascal as
well for the explanation and Roger for twisting my brain for a few hours.
operand =. 2 2 2 $ 3 2 2 3 2 3 3 2
bitmask =. 2 2 2 $ 1 0 0 1 0 1 1 0
operator =. >:
bitmask 0&(] operator) operand NB. original
4 3
3 4
3 4
4 3
bitmask 10&(] operator) operand NB. 10& same result
4 3
3 4
3 4
4 3
bitmask ' '&(] operator) operand NB. type is not even important - ' '&
works
4 3
3 4
3 4
4 3
For efficiency, I don't see much difference between the two with these
particular values
1000 timespacex ' bitmask 0&(] operator)"0 operand'
1.013e_6 2816
1000 timespacex 'bitmask (operator@]^:[)"0 operand'
9.38e_7 2816
But the much simpler addition of the bitmask to the operand is 3 times faster
and takes up half the space.
1000 timespacex 'bitmask + operand'
3.14e_7 1408
bitmask + operand
4 2
2 4
2 4
4 2
Cheers, bob
On Aug 17, 2020, at 07:20, Henry Rich <henryhr...@gmail.com> wrote:
In the example above, the 0& could be any value and is used only as a way of
getting the power function.
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
--
This email has been checked for viruses by AVG.
https://www.avg.com
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
