cutoff frequency

2e pi f* f* 1e swap f/ fm. 1.54k  ok.

: test ( --  ) \ test 1'000 times sin, displays time in us
  utime cr
  pi 2e f* 1000e f/  \ 2*pi/1000
  cr
  1000 0 do
\    fdup i s>f f*      fdrop
     fdup i s>f f* fsin fdrop
\    i .  fdup i s>f f* fsin fs.   cr
\    i .  fdup i s>f f* fsin hex. hex.  cr
  loop
  fdrop
  utime 2swap d-
;

Links

• Rounding is not always working properly. Not useful for precision more than 3.

• Newlib
• The Forth Scientific Library e.g. for ANS Forth Complex Arithmetic Lexicon

: test ( --  ) \ test 1'000 times sin, displays time in us
  ucounter cr
  pi 2e f* 1000e f/  \ 2*pi/1000
  cr
  1000 0 do
    fdup i s>f f*      fdrop
\    fdup i s>f f* fsin fdrop
\    i .  fdup i s>f f* fsin fs.   cr
\    i .  fdup i s>f f* fsin hex. hex.  cr
  loop
  fdrop
  utimer
;

RC time constant

2.2n 47k f* fm. 103u  ok.

Words from fixpt-mat-lib.fs

Simple test program to estimate execution time of fsin and fsqrt:

fsqrt takes also about 2 ms for 1000 iterations. Therefore a fsin word takes about 1 us or less.

include /fsr/fixpt-math-lib.fs  ok.

: test-fix ( -- n ) \ test 1000 times fixed-point sin return n in ms
  osKernelGetTickCount  cr
\ pi 2e f* 1000e f/  \ 2*pi/1000
  360,0 1000,0 x/
  cr
  1000 0 do
\   2dup i 0 swap x*      2drop
\   2dup i 0 swap x* sin  2drop
    2dup i 0 swap x* sqrt  2drop
\   i .  2dup i 0 swap x* sin x.   cr
\   i .  2dup i 0 swap x* sqrt x.   cr
\   i .  2dup i 0 swap x* sin hex. hex. cr
  loop
  2drop
  osKernelGetTickCount swap -
;
test-fix .

323 

Only addition and subtraction are comparable:

see d+
080008B6: CF07  ldmia r7 { r0  r1  r2 }   1
080008B8: 1812  adds r2 r2 r0             1
080008BA: 414E  adcs r6 r1                1
080008BC: 3F04  subs r7 #4                1
080008BE: 603A  str r2 [ r7 #0 ]          1
080008C0: 4770  bx lr
                                   Cycles 5

Conclusion

As long as you do only elementary arithmetic, fixed- and floating-point have comparable execution time (but division and multiplication is a magnitude slower). But for more elaborate calculation (trigonomteric, exponential functions) the execution time is for fixed-point at least two magnitudes slower.

If time is not an issue in either development or execution, you can easily do without the FPU.

• fpu.s on GitHub
• fpu.c on GitHub

• Rounding is not always working properly. useful for precision more than 3.

: f. ( r -- )  \ display, with a trailing space, the floating-point number r in fixed-point notation
  $3F000000 \ .5
  precision 0 do
    $41200000 f/ \ 10.0 / 
  loop
  f+            \ round
  f>x
  <# 
     0 #s 2drop    \ integer part
     46 hold<       \ decimal point
     precision 0 do
       x#             \ fract digit
     loop
     dup
  #> 
  type space
; 

• Fixed Point, https://en.wikipedia.org/wiki/Q_(number_format)

• Do not use FPU in interrupt service routines.
• Tasks/Threads with FPU operations need much more return stack depth.
• Rounding is not very useful for precision more than 3.

• What Every Computer Scientist Should Know About Floating-Point Arithmetic

Some Hints for Using the FPU

Rounding is not very useful for precision more than 3.

0.1005e fs. 1.01E-1  ok.
0.1005e fm. 101m ok.
4 set-precision
0.100005e fs. 1.0000E-1  ok.
0.100005e fm. 100.00m ok.

Do not use FPU in interrupt service routines.

Tasks/Threads with FPU operations need much more return stack depth.

• Scientific notation
• Engineering notation
• Metric prefix

Words Using the C Math Library

fe. ( r -- ) display, with a trailing space, the floating-point number r in engineering notation fs. ( r -- ) display, with a trailing space, the floating-point number r in scientific notation fu. ( r -- ) display, with a trailing space, the floating-point number r in (metric) unit prefix notation

fsinh ( r1 -- r2 ) r2 is the hyperbolic sine of r1 fcosh ( r1 -- r2 ) r2 is the hyperbolic cosine of r1 ftanh ( r1 -- r2 ) r2 is the hyperbolic tangent of r1 fasinh ( r1 -- r2 ) r2 is the floating-point value whose hyperbolic sine is r1 facosh ( r1 -- r2 ) r2 is the floating-point value whose hyperbolic cosine is r1 fatanh ( r1 -- r2 ) r2 is the floating-point value whose hyperbolic tangent is r1

fceil ( r1 -- r2 ) return the smallest integral value that is not less than r1 ffloor ( r1 -- r2 ) Round r1 to an integral value using the "round toward negative infinity" rule, giving r2

fexp ( r1 -- r2 ) raise e to the power r1, giving r2. f** ( r1 r2 -- r3 ) raise r1 to the power r2, giving the product r3

fln ( r1 -- r2 ) r2 is the natural logarithm of r1 flog ( r1 -- r2 ) r2 is the base-ten logarithm of r1

• Single-precision floating-point format
• Double-precision floating-point format

Fixed-Point Words

Fixed-point numbers (s31.32) are stored ( n-comma n-whole ) and can be handled like signed double numbers. Because of the name conflict with the floating-point words I changed the names of the fixed-point word and use for fixed-point words x instead of f.

All angles are in degrees.

d+      ( x1 x2 -- x3 )     add x1 to x2 giving the sum x3
d-      ( x1 x2 -- x3 )     subtract x2 from x1, giving x3
x*      ( x1 x2 -- x3 )     multiply x1 by x2 giving x3
x/      ( x1 x2 -- x3 )     divide x1 by x2, giving the quotient x3
x.      ( x --  )           display, with a trailing space, the fixed-point number x
x.n 	( x n -- ) 	    print a fixed-point number x with n fractional digits (truncated)
x#S 	( n1 -- n2 ) 	    Adds 32 comma-digits to number output
x# 	( n1 -- n2 ) 	    Adds one comma-digit to number output

sqrt    ( x1 -- x2 )        x2 is the square root of x1
sin
cos
tan
asin
acos
atan
log2
log10
ln
pow2
pow10
exp

floor
deg2rad ( deg -- rad )
rad2deg ( rad -- deg )

pi
pi/2
pi/4
+inf
-inf

fixpt-mat-lib.fs

f. ( r -- ) display, with a trailing space, the floating-point number r in fixed-point notation fe. ( r -- ) display, with a trailing space, the floating-point number r in engineering notation fs. ( r -- ) display, with a trailing space, the floating-point number r in scientific notation precision ( -- u ) return the number of significant digits currently used by F., FE., or FS. as u set-precision ( u -- ) set the number of significant digits currently used by F., FE., or FS. to u

Fixed-Point Words

• https://mcuoneclipse.com/2019/03/29/be-aware-floating-point-operations-on-arm-cortex-m4f/
• http://support.raisonance.com/content/how-should-i-use-floating-point-unit-fpu-cortex-m4

• https://en.wikipedia.org/wiki/IEEE_754
• https://en.wikipedia.org/wiki/Single-precision_floating-point_format

fabs ( r1 -- r2 ) r2 is the absolute value of r1 fnegate ( r1 -- r2 ) r2 is the negation of r1 fround ( r1 -- r2 ) round r1 to an integral value using the "round to nearest" rule, giving r2

fflags@ ( -- u ) get the current value of the Floating Point Status/Control register FPSCR fflags! ( -- u ) assign the given value to the Floating Point Status/Control register FPSCR

f0= ( r -- ? ) flag is true if r is equal to zero f0< ( r -- ? ) flag is true if r is less than zero f< ( r1 r2 -- ? ) flag is true if r1 is less than r2

FPU's Dark Corners

STM AN4044

Floating-point calculations require a lot of resources, as for any operation between two numbers. For example, we need to:

• Align the two numbers (have them with the same exponent)
• Perform the operation
• Round out the result
• Code the result

On an FPU-less processor, all these operations are done by software through the C compiler library (or Forth Words) and are not visible to the programmer; but the performances are very low. On a processor having an FPU, all of the operations are entirely done by hardware in a single cycle, for most of the instructions. The C (or Forth) compiler does not use its own floating-point library but directly generates FPU native instructions.

When implementing a mathematical algorithm on a microprocessor having an FPU, the programmer does not have to choose between performance and development time. The FPU brings reliability allowing to use directly any generated code through a high level tool, such as MATLAB or Scilab, with the highest level of performance.

Normalized Numbers Range

IEEE.754 Single and Double Precision Floating-Point Coding

Some Links

• https://forth-standard.org/standard/float
• https://de.wikipedia.org/wiki/IEEE_754

Why Floating-Point?

STM AN4044: One alternative to floating-point is fixed-point, where the exponent field is fixed. But if fixed-point is giving better calculation speed on FPU-less processors, the range of numbers and their dynamic is low. As a consequence, a developer using the fixed-point technique will have to check carefully any scaling/saturation issues in the algorithm.

Floating-Point Unit

Floating-Point Words

Bare FPU Words (Without C Math Library)

Words Using C Math Library

fsin    ( r1 -- r2 )       r2 is the sine of the radian angle r1

C Math Library

• Fixed Point

• printf("%f", myFloat) f. fe. fs.

• math.h e.g. float cosf (float)

• printf("%f", myFloat)
• atof() oder strtof() benutzen?

• f. fe. fs.

• https://interrupt.memfault.com/blog/cortex-m-rtos-context-switching ARM Cortex-M RTOS Context Switching

• nur single-precision? (7..8 Dezimalstellen, H7 hat double precision FPU)

Cell to_float(Char *c_addr, UCell u, Float *rp)
{
  /* convertible string := <significand>[<exponent>]
     <significand> := [<sign>]{<digits>[.<digits0>] | .<digits> }
     <exponent>    := <marker><digits0>
     <marker>      := {<e-form> | <sign-form>}
     <e-form>      := <e-char>[<sign-form>]
     <sign-form>   := { + | - }
     <e-char>      := { D | d | E | e }
  */
  Char *s = c_addr;
  Char c;
  Char *send = c_addr+u;
  UCell ndigits = 0;
  UCell ndots = 0;
  UCell edigits = 0;
  char cnum[u+3]; /* append at most "e0\0" */
  char *t=cnum;
  char *endconv;
  Float r;
  
  if (s >= send) /* treat empty string as 0e */
    goto return0;
  switch ((c=*s)) {
  case ' ':
    /* "A string of blanks should be treated as a special case
       representing zero."*/
    for (s++; s<send; )
      if (*s++ != ' ')
        goto error;
    goto return0;
  case '-':
  case '+': *t++ = c; s++; goto aftersign;
  }
  aftersign: 
  if (s >= send)
    goto exponent;
  switch (c=*s) {
  case '0' ... '9': *t++ = c; ndigits++; s++; goto aftersign;
  case '.':         *t++ = c; ndots++;   s++; goto aftersign;
  default:                                    goto exponent;
  }
 exponent:
  if (ndigits < 1 || ndots > 1)
    goto error;
  *t++ = 'E';
  if (s >= send)
    goto done;
  switch (c=*s) {
  case 'D':
  case 'd':
  case 'E':
  case 'e': s++; break;
  }
  if (s >= send)
    goto done;
  switch (c=*s) {
  case '+':
  case '-': *t++ = c; s++; break;
  }
 edigits0:
  if (s >= send)
    goto done;
  switch (c=*s) {
  case '0' ... '9': *t++ = c; s++; edigits++; goto edigits0;
  default: goto error;
  }
 done:
  if (edigits == 0)
    *t++ = '0';
  *t++ = '\0';
  assert(t-cnum <= u+3);
  r = strtod(cnum, &endconv);
  assert(*endconv == '\0');
  *rp = r;
  return -1;
 return0:
  *rp = 0.0;
  return -1;
 error:
  *rp = 0.0;
  return 0;
}
#endif

• https://forth-standard.org/proposals/recognizer#contribution-142
• https://de.wikipedia.org/wiki/IEEE_754

• atof() benutzen?
• nur single-precision? (7..8 Dezimalstellen)
• kein eigener Stack
• >float wo?
• float register mit mutex absichern?
• float.fs in source integrieren?
• auf float in ISR verzichten
• _FPU_USED
• AN4044 Application note, Foating point unit demonstration on STM32 microcontrollers

• https://forth-standard.org/standard/float

Floating Point Unit

• https://www.complang.tuwien.ac.at/forth/gforth/Docs-html/Number-Conversion.html#Number-Conversion
• https://www.complang.tuwien.ac.at/forth/gforth/Docs-html/Floating-Point.html#Floating-Point

-- Peter Schmid - 2020-10-27

Comments

<--/commentPlugin-->