You can control the precision of all numeric computations using the environment variable Digits. By default, Digits is assigned the value 10, so the evalf command uses 10-digit floating-point arithmetic.

You can assign any positive integer that does not exceed the kernelopts(maxdigits) value to Digits. For more information, see kernelopts.

To specify the numeric precision for an evalf computation without changing the value of Digits, use the optional index in the calling sequence, that is, evalf[n](expression).

To compute a numeric approximation to an unevaluated sum returned by the Sum or sum command, use the evalf command.

There are times when using the evalf command causes problems mathematically. For example, the rounding error in floating point values can give incorrect solutions to further computations. The following example does not work if you evaluate to a floating point value too early in the computation.

When you specify floating-point arguments in a call to the sin function, it automatically returns a floating-point result.

You can define a new function and corresponding evalf subroutine such that the evalf subroutine is called if the arguments are of floating-point type. To clearly show which code Maple uses, in the following example, the mathematical function returns 2 times the argument for non-floating-point input and 2.01 times the argument for floating-point input.

NewFunction := proc(x)
  local s;
  if type(x,'complex'('float')) then
    s := evalf('NewFunction'(x));
    if type(s,'complex'('float')) then
      return s;
    end if;
  end if;
  return 2*x;
end proc:

`evalf/NewFunction` := proc(xx)
  local x;
  x := evalf(xx);
  if not type(x, 'complex'('float')) then
    return 'NewFunction'(x);
  end if;
  return 2.01*x;
end proc:

You can always use the evalf subroutine by directly calling it or placing unevaluation quotes around instances of the function name.