After thinking about this for a little bit, I have decided that it
should be *almost* straightforward to convert this definition to a
fully tacit form.
The simplest tactic would be to define tacit expressions for each of
the local names in the definition, but that would result in
significant repeat work.
But we can use trains to calculate and save two values and of course a
third value can be calculated inside the train if it's used only once.
So, looking at the structure of the definition:
labels=: ;:'y undx uval ucnt useg reps sndx segs result'
reset=:{{
connections=:0$~2##labels
}}
depends=:{{
connections=:1 ({(labels i.;:x);(#labels)-.~labels i.;:y)} connections
}}
reset''
'uval' depends ' undx {./. y'
'ucnt' depends ' #/.~ undx'
'useg' depends ' ((2 ~:/\ ]),0#~0<#) * 2 -/\ uval'
'reps' depends ' ucnt*1,1+useg'
'sndx' depends ' +/\reps'
'segs' depends ' (1,useg) (sndx-ucnt)} 0#~{:sndx'
'result' depends ' segs<;.1 reps#uval'
We can also see that each value is used by at most two other values
which is promising:
+/connections
1 2 2 2 2 2 1 1 0
And, we can remind ourselves that each value depends on at most three
other values, which is also promising:
+/"1 connections
0 0 2 1 1 2 1 3 3
But those last two could use some further inspection:
Looking at the computation for segs:
(labels i.;:'useg sndx ucnt') { +/connections
2 1 2
sndx is only used once, so it could be computed inside a train. But,
it appears twice in the expression, so we would need to rearrange
things to eliminate that as a problem. Perhaps the simplest approach
would be to replace those two uses with +/\reps and +/reps.
Looking at the result, we see:
(labels i.;:'segs reps uval') { +/connections
1 2 2
Here, segs itself is used only once.
After this inspection, it seems like it should be completely
straightforward to convert that definition of updowns to a fully tacit
nested train representation.
And, perhaps this way of thinking about things would be of interest to
some others here in the forums?
--
Raul
On Fri, May 21, 2021 at 8:23 AM Raul Miller <[email protected]> wrote:
>
> Ok...
>
> I didn't feel like trying to make this tacit:
>
> updowns=:{{
> undx=. +/\ 2 ~:/\ (,~ 1+{.) y
> uval=. undx {./. y
> ucnt=. #/.~ undx
> useg=. ((2 ~:/\ ]),0#~0<#) * 2 -/\ uval
> reps=. ucnt*1,1+useg
> sndx=. +/\reps
> segs=. (1,useg) (sndx-ucnt)} 0#~{:sndx
> segs<;.1 reps#uval
> }}
>
> This is of course quite a bit longer than your Foo, but also somewhat
> faster on long sequences in my trivial tests.
>
> It's less space efficient, perhaps because I've retained all
> intermediate results until the end.
>
> I hope this helps,
>
> --
> Raul
>
>
>
>
> On Fri, May 21, 2021 at 7:21 AM R.E. Boss <[email protected]> wrote:
> >
> > Yep.
> >
> >
> > R.E. Boss
> >
> >
> > -----Original Message-----
> > From: Programming <[email protected]> On Behalf Of
> > Raul Miller
> > Sent: vrijdag 21 mei 2021 12:47
> > To: Programming forum <[email protected]>
> > Subject: Re: [Jprogramming] ups & downs
> >
> > Ok... so... this is correct behavior?
> >
> > Foo 1 10 1 # 1 2 1
> > +---------------------+---------------------+
> > |1 2 2 2 2 2 2 2 2 2 2|2 2 2 2 2 2 2 2 2 2 1|
> > +---------------------+---------------------+
> >
> > Thanks,
> >
> > --
> > Raul
> >
> >
> > On Fri, May 21, 2021 at 4:09 AM R.E. Boss <[email protected]> wrote:
> > >
> > > ud 2#1 2 1 2 1
> > > +-------+-----+-----+-----+
> > > |1 1 2 2|2 1 1|1 2 2|2 1 1|
> > > +-------+-----+-----+-----+
> > > Foo 2#1 2 1 2 1
> > > +-------+-------+-------+-------+
> > > |1 1 2 2|2 2 1 1|1 1 2 2|2 2 1 1|
> > > +-------+-------+-------+-------+
> > >
> > > the latter being the required, maximal length ups & downs.
> > >
> > > OTOH, Foo does not handle correct your first two values 4#1 and 3#1 2.
> > > But they are rather trivial ones, being constant or only one up (or
> > > down), I can live with that. An easy check could filter that out.
> > >
> > >
> > > R.E. Boss
> > >
> > >
> > > -----Original Message-----
> > > From: Programming <[email protected]> On Behalf Of
> > > Raul Miller
> > > Sent: vrijdag 21 mei 2021 00:32
> > > To: Programming forum <[email protected]>
> > > Subject: Re: [Jprogramming] ups & downs
> > >
> > > Bugfix:
> > >
> > > reps=: 1+0,~0,2~:/\[:[^:(0~:[)/\.&|.^:2@:*2 -/\]
> > > ud=: reps ((1,2 =/\ [ # #\@]) <;.1 #) ]
> > >
> > > This fixes a problem where the duplicate values appeared at the end of
> > > the sequence.
> > >
> > > Here are some values to test against:
> > > 4#1
> > > 3#1 2
> > > 2#1 2 1 2 1
> > >
> > > I think I've dealt with all of these correctly (though of course, there's
> > > some ambiguity where a run of equal values appears at the edge of an
> > > up/down border). But let me know if I should be doing this differently.
> > >
> > > Thanks,
> > >
> > > --
> > > Raul
> > >
> > > On Thu, May 20, 2021 at 12:17 PM Raul Miller <[email protected]>
> > > wrote:
> > > >
> > > > Oh... I see...
> > > >
> > > > I noticed that the ravel of the boxes did not match the original
> > > > sequence and did not look close enough after that.
> > > >
> > > > Anyways, I guess here's how I would approach this:
> > > >
> > > > reps=: 1+0,~0,2~:/\[:[^:(0~:[)/\.@:*2 -/\]
> > > > ud=: reps ((1,2 =/\ [ # #\@]) <;.1 #) ]
> > > >
> > > > Thanks,
> > > >
> > > > --
> > > > Raul
> > > >
> > > > On Thu, May 20, 2021 at 10:42 AM R.E. Boss <[email protected]> wrote:
> > > > >
> > > > > I thought it was clear from the output (therefore I used ?. in the
> > > > > testcases) that the order of the input array should not be altered.
> > > > > That was the constraint you were missing.
> > > > >
> > > > >
> > > > > R.E. Boss
> > > > >
> > > > >
> > > > > -----Original Message-----
> > > > > From: Programming <[email protected]> On
> > > > > Behalf Of Raul Miller
> > > > > Sent: donderdag 20 mei 2021 16:33
> > > > > To: Programming forum <[email protected]>
> > > > > Subject: Re: [Jprogramming] ups & downs
> > > > >
> > > > > I could use some additional details.
> > > > >
> > > > > I mean... it seems to me that Foo=:<@/:~ would minimally satisfy the
> > > > > requirements which have been stated so far.
> > > > >
> > > > > But, presumably, there's some kind of "cost function" which we are
> > > > > trying to minimize, and presumably that has something to do with how
> > > > > pairs are handled?
> > > > >
> > > > > Or, perhaps, you have a constraint that no more than three of any
> > > > > given number may appear in any box, and I think I see a constraint
> > > > > that adjacent boxes must alternate their order. But perhaps there are
> > > > > also similar additional metrics or constraints?
> > > > >
> > > > > Thanks,
> > > > >
> > > > > --
> > > > > Raul
> > > > >
> > > > > On Thu, May 20, 2021 at 6:43 AM R.E. Boss <[email protected]>
> > > > > wrote:
> > > > > >
> > > > > > Given an array of numbers, like
> > > > > >
> > > > > > ?.@#~20
> > > > > > 14 16 8 6 5 8 6 16 16 19 13 12 3 1 9 12 17 0 9 5
> > > > > >
> > > > > > there is always a sequence of (non-strict) ups & downs, like
> > > > > >
> > > > > > 14 16;16 8 6 5;5 8;8 6;6 16 16 19;19 13 12 3 1; 1 9 12 17;17
> > > > > > 0;0
> > > > > > 9;9 5
> > > > > > +-----+--------+---+---+----------+------------+---------+----+---+---+
> > > > > > |14 16|16 8 6 5|5 8|8 6|6 16 16 19|19 13 12 3 1|1 9 12 17|17 0|0
> > > > > > |9|9
> > > > > > |5|
> > > > > > +-----+--------+---+---+----------+------------+---------+----+---+---+
> > > > > >
> > > > > > Well, this is the way I prefer to have the ups & downs, where they
> > > > > > share their border terms.
> > > > > > Which verb makes this transformation?
> > > > > > Elegance, as always, is appreciated, correctness is a must,
> > > > > > efficiency a blessing.
> > > > > >
> > > > > > Some testcases:
> > > > > >
> > > > > > Foo ?.@#~25
> > > > > > +----+---+---+-------+-----+-----+----+---+---+----+-------+----+----+-------+----+----+----+----+------+---+
> > > > > > |19 6|6 8|8 6|6 10 23|23 16|16 21|21 1|1 9|9 8|8 22|22 13 1|1
> > > > > > |14|14
> > > > > > |2|2 17 20|20 9|9 15|15 7|7 22|22 4 2|2 9|
> > > > > > +----+---+---+-------+-----+-----+----+---+---+----+-------+----+----+-------+----+----+----+----+------+---+
> > > > > > Foo ?.@#~30
> > > > > > +--------+------+----+--------+--------+---------+----+-----+-----+----+----+-----+-----+----+-------+-------+-------+--------+-----+-----+
> > > > > > |24 26 28|28 6 5|5 28|28 16 16|16 16 26|26 19 3 2|2 13|13 11|11
> > > > > > |19|19
> > > > > > |2|2 27|27 10|10 19|19 5|5 17 27|27 19 7|7 24 28|28 27 14|14 22|22
> > > > > > |2|21|
> > > > > > +--------+------+----+--------+--------+---------+----+-----+-----+----+----+-----+-----+----+-------+-------+-------+--------+-----+-----+
> > > > > >
> > > > > >
> > > > > > R.E. Boss
> > > > > > ------------------------------------------------------------------
> > > > > > ---- 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
> > > ----------------------------------------------------------------------
> > > 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
> > ----------------------------------------------------------------------
> > For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
