Re: Avoid treating the stack as an array [Re: "Back & Forth" is back!]

On Sat, 14 Sep 2024 15:08:36 +0000, Anton Ertl wrote:

I wonder if the notation "mf(x;a,b,c)" indicates that a,b,c is a tuble
that tends to get passed around without changing it.  In that case
defining it as a structure in memory and accessing its members there
might be a solution.

a, b and are the parameters of the membership function.
Yes, we can use structures, arrays ...

>
But OTOH, unless you see programming in Forth as a religious exercise,
why worry, as long as your solution works.

I did it without locals as an exercise. Here it is:
Without locals:
: tri_mf: ( f: a b c )
     create frot f, fswap f, f,
     does>             ( ad_a)           ( f: x)
       dup fdup        ( ad_a ad_a)      ( f: x x)
       f@              ( ad_a)           ( f: x x a)
       f>=             ( ad_a -1|0)      ( f: x)
       over float+     ( ad_a -1|0 ad_b) ( f: x)
       fdup f@         ( ad_a -1|0)      ( f: x x b)
       f< and if       ( ad_a)           ( f: x)
         dup f@ f-     ( ad_a)           ( f: x-a)
         dup f@        ( ad_a)           ( f: x-a a)
         float+        ( ad_b)           ( f: x-a a)
         f@ fswap f-                     ( f: x-a b-a)
         f/                              ( f: [x-a]/[b-a])
         exit
       then
       float+          ( ad_b)           ( f: x)
       dup fdup        ( ad_b ad_b)      ( f: x x)
       f@              ( ad_b)           ( f: x x b)
       f>=             ( ad_b -1|0)      ( f: x)
       over float+     ( ad_b -1|0 ad_c) ( f: x)
       fdup f@         ( ad_b -1|0)      ( f: x x c)
       f< and if       ( ad_b)           ( f: x)
         dup float+ f@ ( ad_b)           ( f: x c)
         f-            ( ad_b)           ( f: x-c)
         dup float+    ( ad_b ad_c)      ( f: x-c)
         swap f@ f@ f-                   ( f: x-c b-c)
         f/                              ( f: [x-c]/[b-c])
         exit
       then
       drop fdrop
       0e
;
-1e309  -1e    0e    tri_mf: neg_big
-1e      0e    1e    tri_mf: zero
 0e      1e    1e309 tri_mf: pos_big
: fuzzify ( f: x)
    fdup neg_big cr f.
    fdup zero    cr f.
         pos_big cr f.
;
Examples: for x in {-10e, -1e, -0.8e, -0.5e, -0.3e, 0e, 0.2e, 0.5e,
0.7e, 1e, 20e}
-10e fuzzify and so on.
\ ---------------
With locals:
: tri_mf() { f: x f: a f: b f: c } ( f: x a b c -- mv)
     x a f>= x b f< and if x a f- b a f- f/ exit then
     x b f>= x c f< and if c x f- c b f- f/ exit then
     0e
;
: neg_big -1e309 -1e   0e    tri_mf() ;
: zero    -1e     0e   1e    tri_mf() ;
: pos_big  0e     1e   1e309 tri_mf() ;
: fuzzify { f: x }
    x neg_big cr f.
    x zero    cr f.
    x pos_big cr f.
;
Examples: for x in {-10e, -1e, -0.8e, -0.5e, -0.3e, 0e, 0.2e, 0.5e,
0.7e, 1e, 20e}
-10e fuzzify and so on.
I notice a great difference in readibality and simplicity when using
locals.
Using gforth under WSL (Windows Subsystem for Linux):
utime 0.1e neg_big utime d- dnegate d.
with locals:    about 19 ms
without locals: about 18 ms
Ahmed