[Jprogramming] sequential machine
Arnab Chakraborty
arnabc74 at gmail.com
Tue Feb 20 12:30:32 UTC 2018
Thanks a lot for your detailed comments. In fact, I have started to think
that using verb"0 that accumulates results is really bad, because it
violates the basic notion of rank 0. Actually it is rank 1 hidden behind
rank 0. Also any array language has the potential of using a multicore
system by parallel processing the elements. But then my solution would give
completely unpredictable result.
So using ;: is indeed the superior approach.
On 20 Feb 2018 09:28, "Raul Miller" <rauldmiller at gmail.com> wrote:
> Hmm... I think you should view the state machine as a component in a
> larger system.
>
> I say this because other languages tend to encourage you to push
> functionality into loops [loops are a bit laborious and noisy to
> write, so you tend to want to not write many of them], but that's not
> always a good idea.
>
> So - for example - when using the ;: primitive, it can be entirely
> reasonable to add preprocessing and/or postprocessing, if that makes
> the job simpler.
>
> It can also be reasonable to use for loops (or sometimes even while
> loops), or whatever else -- if my "state machine" needed a stack, I
> think I'd be tempted to use a for loop (but note that if the stack is
> simple enough it might be easier to represent stack depth using
> addition and break out the "stack handling" into a separate
> expression, like +/\-/'()'=/text for example).
>
> It can even be reasonable to use side effects to communicate
> computational progress between (verb"0) invocations, like you are
> doing here, but for whatever reason I usually shy away from that.
>
> That said, once I have a first draft implementation, that I can see,
> test and understand, I sometimes I like to rewrite it (perhaps using
> primitives instead of explicit loops). [And I should get in the habit
> of doing performance tests when this gets multiple working versions -
> but, all too often, unless performance problems make themselves known,
> I pick based on other criteria, like which one looks simpler to me.]
>
> That's all that I can think of that might be relevant...
>
> Thanks,
>
> --
> Raul
>
>
> On Mon, Feb 19, 2018 at 9:56 PM, Arnab Chakraborty <arnabc74 at gmail.com>
> wrote:
> > Hello Raul,
> >
> > I have been able to understand the code you sent
> > me. Thanks. Your code helped me to learn some other nuances of
> > J as well! I had come to a somewhat different solution before I saw
> you
> > reply.
> > Here it is for comparison. Actually I did not use ;: at all. Instead,
> I
> > chose a more traditional
> > textbook definition of a state machine (here I skip the input mapping
> > stage, and consider 0,1,2 for a,b,c):
> >
> > sm=:3 :'(s=: s sf y) ] s of y' NB. s=state (a global), sf=state
> > function, of=output function
> >
> > sf and of can be defined any way I like. Here I used the table look up
> > method.
> >
> > sf=.4 :'(<x, y,0){ sot '
> > of=.4 :'(<x, y,1){ sot '
> >
> > The state/output table sot is again like a traditional table, the
> output
> > being 0,1,2,3 (0=none, 1='alpha',2='beta',3='c')
> >
> > sot=. 4 3 2 $ 1 1 2 2 3 3 1 0 2 2 3 3 1 1 2 0 3 3 1 1 2 2 3
> 3
> >
> > The output mapping is
> >
> > om=.(i.0);'alpha';'beta';'c'
> >
> > To run the machine:
> >
> > s=.0
> > out=.(sm"0) 0 0 0 1 1 1 1 2 2
> > ;out { om
> >
> > I was trying to compare your approach with mine:
> >
> > 1) I guess yours is more efficient as it uses the primitive
> > ;:
> > 2) I am relying on the undocumented feature that (sm"0)
> > will apply on each entry sequentially from left to right.
> > 3) My approach is more flexible, especially when I use the
> > machine as a driver for some software (say in robotics). I
> > say this with some apprehension, as J might have some
> > surprise up its long sleeve to disprove this point. For
> > example, what if I want something like this: a run of a's
> > should become 'alpha' if preceeded by a 'b', but should
> > become 'zeta' otherwise. Then I guess in your approach the
> > replacer function will need to be made more complex
> > (please correct me if I am wrong here).
> > 4) There are some situtations where the state function can be
> > efficiently implemented algorithmically (instead of by
> > table look up, which will require a huge table). Then use
> > of ;: will become difficult.
> >
> > I would love to hear your comments.
> >
> >
> > Thanks and regards,
> >
> > Arnab
> >
> > On Mon, Feb 19, 2018 at 2:02 PM, Arnab Chakraborty <arnabc74 at gmail.com>
> > wrote:
> >
> >> Wow, thank you so much, friends, for so much help. With my present level
> >> of profficiency in J, I'll need some time before I can make complete
> sense
> >> of the J codes. Shall report back after that.
> >>
> >>
> >> On 19 Feb 2018 01:10, "Cliff Reiter" <reiterc at lafayette.edu> wrote:
> >>
> >>> A cut variant of "words"
> >>> (<;.1~1,2 ~:/\ ])I
> >>>
> >>> +-+----+---+---+-----+----+
> >>>
> >>> |a|bbbb|aaa|ccc|aaaaa|bbbb|
> >>>
> >>> +-+----+---+---+-----+----+
> >>>
> >>>
> >>>
> >>>
> >>> On 2/18/2018 1:22 PM, David Lambert wrote:
> >>>
> >>>> While not answering your question, the verbs f f g and h solve the
> >>>> problem. The first f uses complex copy to expand the input into same
> >>>> letter groups then applies the correct substitutions to each group.
> >>>>
> >>>> group=: #~ (1 j. 0 ,~ 2 ~:/\ ])
> >>>> words=: ;:@:group
> >>>> substitute=: [: ; ('alpha'"_)`('beta'"_)`]@.('abc' i. {.)&.>
> >>>>
> >>>> f=: [: substitute words
> >>>>
> >>>> I=:'abbbbaaacccaaaaabbbb'[O=:'alphabetaalphacccalphabeta'
> >>>> (O -: f) I
> >>>> 1
> >>>>
> >>>>
> >>>> Realizing I had overlooked `cut', words can also be written more
> >>>> directly as
> >>>>
> >>>> words=: <;.2~ (1 ,~ 2 ~:/\ ])
> >>>> (O -: f) I
> >>>> 1
> >>>>
> >>>> We can mash it together
> >>>> g=: [: ; (<@(('alpha'"_)`('beta'"_)`]@.('abc'i.{.));.2~
> (1,~2~:/\]))
> >>>> (O-:g) I
> >>>> 1
> >>>>
> >>>>
> >>>> Or use no boxes, but this idea depends on your actual application.
> >>>> Accept the fill and remove it later.
> >>>>
> >>>> h=: ' ' -.~ [: , ((('alpha'"_)`('beta'"_)`]@.('abc'i.{.));.2~
> >>>> (1,~2~:/\]))
> >>>> (O-:h) I
> >>>> 1
> >>>>
> >>>>
> >>>> On 02/18/2018 07:00 AM, programming-request at forums.jsoftware.com
> wrote:
> >>>>
> >>>>> Date: Sun, 18 Feb 2018 14:08:45 +0530
> >>>>> From: Arnab Chakraborty<arnabc74 at gmail.com>
> >>>>> To:programming at jsoftware.com
> >>>>> Subject: [Jprogramming] sequential machine
> >>>>> Message-ID:
> >>>>> <CAM3RRn36JTQdtq_=cvHMwXYCsGafJBmufmi4oUGo00zuRuzWWA at mail.
> gmail.com
> >>>>> >
> >>>>> Content-Type: text/plain; charset="UTF-8"
> >>>>>
> >>>>> Hello,
> >>>>>
> >>>>> I use state machines a lot in my programs (in other
> >>>>> languages). I am trying to understand how I can use J for
> >>>>> those purposes. I have read the Sequential Machines and
> >>>>> Huffman Coding labs. But I am unable to see how to solve this
> >>>>> toy problem (without using regexp):
> >>>>>
> >>>>> Input alphabet {a,b,c}
> >>>>> I want to replace runs of 'a' with the word 'alpha', runs of 'b'
> >>>>> with the word 'beta', and leave the 'c's unchanged.
> >>>>>
> >>>>> For example, abbbbaaacccaaaaabbbb becomes
> >>>>> alphabetaalphacccalphabeta.
> >>>>>
> >>>>> The state diagram is like this, where the arcs are labelled as
> >>>>> inp/out.
> >>>>>
> >>>>>
> >>>>> [Cannot inline image]
> >>>>>
> >>>>> I have created the input map successfully (not sure if it is a
> >>>>> good way, though):
> >>>>>
> >>>>> makemap =. 3 : '+/ (>:i.#y) *"0 1 a.="1 0 y'
> >>>>> m=.makemap 'abc'
> >>>>>
> >>>>> I guess that this can be achieved using only outputs 0 and
> >>>>> 2, since I am just interested in the runs.
> >>>>>
> >>>>>
> >>>>> Also, since the output is not just a part of the input, f
> >>>>> must be 2 or 3 or 4.
> >>>>>
> >>>>> But I am stuck at this point. If I use f=.2, then I can get
> >>>>> a list of boundaries of all the runs. If I have to write another
> >>>>> verb that will convert this list to the desired output, then
> >>>>> basically I have to implement a simplified version of the same
> >>>>> state machine inside that verb, which does not look good.
> >>>>>
> >>>>> f=.3 does not look promising either, since for 'c' I need to
> >>>>> know the length of the run.
> >>>>>
> >>>>> How should I proceed?
> >>>>>
> >>>>>
> >>>>> Thanks and regards,
> >>>>>
> >>>>> Arnab
> >>>>>
> >>>>
> >>>> ------------------------------------------------------------
> ----------
> >>>> 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
More information about the Programming
mailing list