Go to the Next or Previous section, the Detailed Contents, or the Amiga E Encyclopedia.


15.3 Floating-Point Functions

There are functions for formatting floating-point numbers to E-strings (so that they can be printed) and for decoding floating-point numbers from strings. There are also a number of built-in, floating-point functions which compute some of the less common mathematical functions, such as the various trigonometric functions.

RealVal(string)
This works in a similar way to Val for extracting integers from a string. The decoded floating-point value is returned as the regular return value, and the number of characters of string that were read to make the number is returned as the first optional return value. If a floating-point value could not be decoded from the string then zero is returned as the optional return value and the regular return value will be zero (i.e., 0.0).

RealF(e-string,float,digits)
Converts the floating-point value float into a string which is stored in e-string. The number of digits to use after the decimal point is specified by digits, which can be zero to eight. The floating-point value is rounded to the specified number of digits. A value of zero for digits gives a result with no fractional part and no decimal point. The e-string is returned by this function, and this makes it easy to use with WriteF.

PROC main()
  DEF s[20]:STRING, f, i
  f:=21.60539
  FOR i:=0 TO 8
    WriteF('f is \s (using digits=\d)\n', RealF(s, f, i), i)
  ENDFOR
ENDPROC
Notice that the floating-point argument, f, to RealF does not need a leading ! because we are simply passing its value and not performing a computation with it. The program should generate the following output:

f is 22 (using digits=0)
f is 21.6 (using digits=1)
f is 21.61 (using digits=2)
f is 21.605 (using digits=3)
f is 21.6054 (using digits=4)
f is 21.60539 (using digits=5)
f is 21.605390 (using digits=6)
f is 21.6053900 (using digits=7)
f is 21.60539000 (using digits=8)
Fsin(float), Fcos(float), Ftan(float)
These compute the sine, cosine and tangent (respectively) of the supplied float angle, which is specified in radians.

Fabs(float)
Returns the absolute value of float, much like Abs does for integers.

Ffloor(float), Fceil(float)
The Ffloor function rounds a floating-point value down to the nearest, whole floating-point value. The Fceil function rounds it up.

Fsqrt(float)
Returns the square root of float.

Fpow(x,y), Fexp(float)
The Fpow function returns the value of x raised to the power of y (which are both floating-point values). The Fexp function returns the value of e raised to the power of float, where e is the mathematically special value (roughly 2.718282). `Raising to a power' is known as exponentiation.

Flog10(float), Flog(float)
The Flog10 function returns the log to base ten of float (the common logarithm). The Flog function returns the log to base e of float (the natural logarithm). Flog10 and Fpow are linked in the following way (ignoring floating-point inaccuracies):

  x = Fpow(10.0, Flog10(x))
Flog and Fexp are similarly related (Fexp could be used again, using 2.718282 as the first argument in place of 10.0).

  x = Fexp(Flog(x))

Here's a small program which uses a few of the above functions, and shows how to define functions which use and/or return floating-point values.

DEF f, i, s[20]:STRING

PROC print_float()
  WriteF('\tf is \s\n', RealF(s, !f, 8))
ENDPROC

PROC print_both()
  WriteF('\ti is \d, ', i)
  print_float()
ENDPROC

/* Square a float */
PROC square_float(f) IS !f*f

/* Square an integer */
PROC square_integer(i) IS i*i

/* Converts a float to an integer */
PROC convert_to_integer(f) IS Val(RealF(s, !f, 0))

/* Converts an integer to a float */
PROC convert_to_float(i) IS RealVal(StringF(s, '\d', i))

/* This should be the same as Ftan */
PROC my_tan(f) IS !Fsin(!f)/Fcos(!f)

/* This should show float inaccuracies */
PROC inaccurate(f) IS Fexp(Flog(!f))

PROC main()
  WriteF('Next 2 lines should be the same\n')
  f:=2.7; i:=!f!
  print_both()
  f:=2.7; i:=convert_to_integer(!f)
  print_both()

  WriteF('Next 2 lines should be the same\n')
  i:=10;  f:=i!
  print_both()
  i:=10;  f:=convert_to_float(i)
  print_both()

  WriteF('f and i should be the same\n')
  i:=square_integer(i)
  f:=square_float(f)
  print_both()

  WriteF('Next 2 lines should be the same\n')
  f:=Ftan(.8)
  print_float()
  f:=my_tan(.8)
  print_float()

  WriteF('Next 2 lines should be the same\n')
  f:=.35
  print_float()
  f:=inaccurate(f)
  print_float()
ENDPROC

The convert_to_integer and convert_to_float functions perform similar conversions to those done by ! when it occurs in an expression. To make things more explicit, there are a lot of unnecessary uses of !, and these are when f is passed directly as a parameter to a function (in these cases, the ! could safely be omitted). All of the examples have the potential to give different results where they ought to give the same, and this is due to the inaccuracy of floating-point numbers. The last example has been carefully chosen to show this.


Go to the Next or Previous section, the Detailed Contents, or the Amiga E Encyclopedia.