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

On 15/09/2024 3:13 am, Ahmed wrote:

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
;

That appears no better than FVALUEs ...

0e fvalue a
0e fvalue b
0e fvalue c
0e fvalue x

: tri_mf() ( f: x a b c -- mv)
  to c  to b  to a  to x
  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
;