Also,
Also, why doesn't this work:
F=.{{{.n#~y=+/\c1 n=.>:i.100}}
F 19
F(19)
Skip Cave
Cave Consulting LLC
On Sat, Jan 22, 2022 at 11:50 PM Skip Cave wrote:
> Thanks for all the examples. I thought that the solution would be pretty
> straightforward.
>
> c1 gives the number of ones in
Thanks for all the examples. I thought that the solution would be pretty
straightforward.
c1 gives the number of ones in an integer:
* c1=.{{+/1=10#.^:_1]y}}"0*
Test it:
* c1 211*
*2*
So the number of ones from 1 to 81 is:
* +/c1 i.>:81*
*19*
To develop the inverse verb F, we can get a
Apologies, this was sent out Friday January 14, but seems to have been caught
in the mail (possibly due to Fibonacci code) so I am resending.
Meeting of January 13, 2022 Present: Art Anger, Will Gajate, Raul Miller, Bob
Therriault.
Will reported that Joe has made substantial progress on the
Present: Art Anger, Will Gajate, Jon Hough, Devon McCormick, Raul Miller, Bob
Therriault
• Will Gajate reported on the progress that he and Joe Bogner had made
on the J playground. It is now housed on the J Github at
https://github.com/jsoftware/j-playground . Currently, the version
https://www.jsoftware.com/help/dictionary/dhcapdot.htm
Using
H=: {{(m {{m rf %&(*/) n rf=. {{(,m) ^!.1/ i.@[ n +/ .* (i.@[ ^~
]) % !@i.@[)"0}}
erf=: (1 H 1.5)@*: * 2p_0.5&* % ^@:*:
or
rf=: 1 : '(,m) ^!.1/ i.@[' NB. Rising factorial
L1=: 2 : 'm rf %&(*/) n rf'
L2=: (i.@[ ^~ ]) %
> On Jan 22, 2022, at 00:51, 'robert therriault' via Programming
> wrote:
>
> In our nineteenth episode, Aaron Hsu, creator of the Co-dfns APL compiler,
> tells us about his journey to and through APL.
The guest on this episode is indeed Aaron Hsu, we are not asking Henry to do
voice overs
I was thinking recently that it might be advantageous to store array
elements in some order other than ravel order. If you do that, then you
may get better locality by going in a different order, without opening the
can of worms that is concurrency; that seems like a reasonable
implementation
Good point. But execution of J verbs in parallel is a hard problem, one
that will probably be solved by a mechanism to allow the user to call
for it. In that case u"n can be specified to execute in order, but u
will create a new task for the execution.
In general if your verb has side
I meant the execution order guarantee, not the execution repetition
guarantee.
On Sat, 22 Jan 2022, Henry Rich wrote:
The goal is to execute each verb only once. In Roger's original JE there
were many places where the code would start with the hope that all
results would be conformable, and
The goal is to execute each verb only once. In Roger's original JE there
were many places where the code would start with the hope that all
results would be conformable, and then after a few cells a result would
come back with a different type or shape, at which time Roger would
restart the
On Sat, 22 Jan 2022, Henry Rich wrote:
3. Similarly with x u y, where v y is executed before v x, in the
implementation. The language spec is silent
5. When a verb is executed multiple times in a single execution from the
parsing stack, the order of the executions is undefined unless there
Comments on this entire thread:
1. If NuVoc ever makes a false statement for pedagogic reasons, there
should be a note inline to indicate that; please add as needed. NuVoc
is intended as a language reference.
2. The order of evaluation of (f g h) y is not defined. You can be sure
if the
On Sat, 22 Jan 2022, Raul Miller wrote:
domain error
Oops. In my defense, testing would not have proved much, since there is
no j implementation which applies fork tines in parallel :)
That exercise 30 was not specifically about J, but about the application
of J's design concepts to
But you can. Malbolge no doubt is a language.
Am 22.01.22 um 15:45 schrieb Hauke Rehr:
Wrong. Informed by an implementation means: this is a cooperative
thing so there’s no point in mixing random syntax and semantics.
--
--
mail written using NEO
neo-layout.org
I don’t quite get it; or rather, I disagree with most of it:
Am 22.01.22 um 14:07 schrieb Raul Miller:
This difference could be prevented by preventing names from being
updated. And, languages have been implemented with that characteristic
(for example, Haskell). (And, of course, quite a lot
And... I forgot to mention: the second column of my r (the first
column of your r) contains [partial] serial numbers (corresponding to
the z value in the first column of my r (the second column of your r)).
Conceptually, the second column is 0, then ,.D then ,.10 #.>,{D;D then
,.10 #.>,{D;D;D and
Very inspiring…
3 things I was not aware of:
* „cut“ and how you use it with obverse ; in combination with &.
* 'I0‘~ evokes the verb I0
* 'q r'=. automatically unboxes a boxed argument
and the nice use case for fold F..
Thanks. Stefan.
On Fri 21. Jan 2022 at 2:35 PM, Raul Miller wrote:
>
On Sat, Jan 22, 2022 at 7:08 AM Elijah Stone wrote:
> > I have not been able to construct any examples which illustrate the
> > execution order ambiguity which you alluded to
>
> a=: 0
> f=. {{ a=: 1 }}
> g=. {{ a }}
> h=. {{ a=: 2 }}
> (f g h) ''
This gives me a domain error. It's easy to
I am not an implementor nor a designer, and hope not to speak out of turn,
so take my reply for what it is: no, there are no such plans.
I am curious why you think that _^_ should be considered indeterminate.
There seems to me to be no problem with it; the limit as x->_ of x^x is _.
0%0 is
You might want to read https://www.jsoftware.com/papers/zero.htm
And, perhaps https://www.jsoftware.com/help/dictionary/d031.htm
And, possibly https://en.wikipedia.org/wiki/Principal_value
But, succinctly: the current behavior here is a consequence of
deliberate design decisions and changing
I have not been able to construct any examples which illustrate the
execution order ambiguity which you alluded to
a=: 0
f=. {{ a=: 1 }}
g=. {{ a }}
h=. {{ a=: 2 }}
(f g h) ''
If h is executed before f, the result will be 1. If f is executed before
h, the result will be 2. I assume an
Hello,
Seems I've sent the following two emails to the wrong email address.
Forwarding.
TLDR: are there any plans implementing new features in the arithmetic with
infinities so that the indeterminate forms mentioned at the Wolfram
Mathworld link below return _. ? For example: 0%0 and _%_.
Best
Language standards are indeed formal statements, but they cannot be
entirely independent of the machine implementation(s).
Here, some relevant abstractions include:
(1) functional vs. machine state semantics
(2) parallel vs. serial implementation
(3) current vs. future versions
...
That
There are formal definitions of substitutability. These do not apply to
real-world concepts (such as feet) but absolutely apply to formal
languages.
Language semantics are distinct from implementation details. APL has
traditionally resisted standardization and, well, APL2 was a collossal
In our nineteenth episode, Aaron Hsu, creator of the Co-dfns APL compiler,
tells us about his journey to and through APL.
Host: Conor Hoekstra Guest: Henry Rich Panel: Stephen Taylor, Rich Park and
Bob Therriault.
https://www.arraycast.com/episodes/episode19-aaron-hsu
Hmm...
First a tiny bit of philosophy, then a bit of my perspective:
Equivalencies, generally speaking, carry assumptions about relevant
abstractions.
For example, when we are counting, we are counting things which are
the "same", but for them to be counted we require them to be different
in
It has been pointed out (f g h) y is not strictly equivalent to (f y) g (h y)
because it is not guaranteed that the right and left tines of a fork will
be applied in sequence. See also the recent thread 'can i trust `:0 to
always execute left to right?'
Does the same caveat apply to & and &:
27 matches
Mail list logo
