Versions of DO ..+LOOP with Floats?

[SirWumpus]

I just realised there does not appear to be any DO..+LOOP equivalents using floating point limit and index. Is there some extension for this or suggested technique I'm not grokking this moment?

[ruv]

I do not know of any construct similar to DO-LOOP with a floating-point index.

To to this, you can use the BEGIN-WHILE-REPEAT loop and float variables for the index and limit.

Here is an example of a function that takes a callback and executes it in a loop while the index is within a given range.

0e fvalue dfw.r.lower
0e fvalue dfw.r.upper
' abort value dfw.callback

: do-float-within ( any xt.callback -- any ; F: any r.index.start r.lower r.upper -- any r.index.out-of-the-range )
  \ Execute the callback while the index in the range [ r.lower , r.upper )
  \ xt.callback => ( F: any r.index1 -- any r.index2 ; S: any -- any )
  dfw.r.upper f>r  dfw.r.lower f>r  dfw.callback >r
  to dfw.r.upper  to dfw.r.lower  to dfw.callback
  begin ( F: r.index1 )
    fdup dfw.r.upper f< while
    fdup dfw.r.lower f< 0= while
    dfw.callback execute ( F: r.index2 )
  repeat then ( F: r )
  r> to dfw.callback  fr> to dfw.r.lower  fr> to dfw.r.upper
;

Usage example:

  0e 0e 10e  [: ( F: r -- r ) fdup f. 0.7e f+ ;] do-float-within fdrop  cr
  \ output: 0. 0.7 1.4 2.1 2.8 3.5 4.2 4.9 5.6 6.3 7. 7.7 8.4 9.1 9.8

This function requires the words f>r and fr> (see the corresponding proposal).

NB: this function will not work correct if a callback does not return control in a recursive call of this function (due to catch/throw). To fix that, catch (with restoring the variables and re-throw) must be used instead of execute .

[SirWumpus]

Ok. I figured it end up being a "roll your own" thing.

As for the word F>R and FR>, I had already implemented similar in Post4 with different names fs>rs and rs>fs. The reason for the different names become clear below.

SIDEBAR: I notice too that there is no means to move a float from/to the data stack without conversion, eg.

\ Move r between stacks _without_ conversion; F>D, F>S, D>F, and S>F convert formats.
: fs>ds ( S: -- r ) ( F: r -- ) fs>rs R> ;
: ds>fs ( S: r -- ) ( F: -- r ) >R rs>fs ;

If you want to do any manipulation of the raw float, you need to use the data stack since it supports bit and shift operations.

[ruv]

If you want to do any manipulation of the raw float, you need to use the data stack since it supports bit and shift operations.

Yes, but that manipulations will depend on the implementation details of the Forth system. For example, in some implementations, a floating point number occupies two cells on the data stack. A portable way is not very efficient: you have to write the floating point number to memory, and then read it (or its part) as a tuple of bits from the memory onto the data stack.

The reason for the different names become clear below.

Do you mean that your use the common naming format {source-stack-id}>{target-stack-id} for these words?

The names f>r and fr> follow the format {what}>r, {what}r>, where the empty what denotes a cell (from the data stack, and into the data stack, respectively), f denotes a floating point number. These words names do not depend on whether the floating-point stack is separate or united with the data stack.