summaryrefslogtreecommitdiff
path: root/doc
diff options
context:
space:
mode:
Diffstat (limited to 'doc')
-rw-r--r--doc/coreutils.texi82
1 files changed, 33 insertions, 49 deletions
diff --git a/doc/coreutils.texi b/doc/coreutils.texi
index 0b142c7ad..35134366f 100644
--- a/doc/coreutils.texi
+++ b/doc/coreutils.texi
@@ -13539,9 +13539,16 @@ Options must precede operands.
@opindex -f @var{format}
@opindex --format=@var{format}
@cindex formatting of numbers in @command{seq}
-Print all numbers using @var{format}; default @samp{%g}.
-@var{format} must contain exactly one of the floating point
-output formats @samp{%e}, @samp{%f}, or @samp{%g}.
+Print all numbers using @var{format}.
+@var{format} must contain exactly one of the @samp{printf}-style
+floating point conversion specifications @samp{%a}, @samp{%e},
+@samp{%f}, @samp{%g}, @samp{%A}, @samp{%E}, @samp{%F}, @samp{%G}.
+
+The default format is derived from @var{first}, @var{step}, and
+@var{last}. If these all use a fixed point decimal representation,
+the default format is @samp{%.@var{p}f}, where @var{p} is the minimum
+precision that can represent the output numbers exactly. Otherwise,
+the default format is @samp{%g}.
@item -s @var{string}
@itemx --separator=@var{string}
@@ -13552,34 +13559,17 @@ The output always terminates with a newline.
@item -w
@itemx --equal-width
Print all numbers with the same width, by padding with leading zeroes.
+@var{first}, @var{step}, and @var{last} should all use a fixed point
+decimal representation.
(To have other kinds of padding, use @option{--format}).
@end table
-If you want to use @command{seq} to print sequences of large integer values,
-don't use the default @samp{%g} format since it can result in
-loss of precision:
-
-@example
-$ seq 1000000 1000001
-1e+06
-1e+06
-@end example
-
-Instead, you can use the format, @samp{%1.f},
-to print large decimal numbers with no exponent and no decimal point.
-
-@example
-$ seq --format=%1.f 1000000 1000001
-1000000
-1000001
-@end example
-
-If you want hexadecimal output, you can use @command{printf}
+If you want hexadecimal integer output, you can use @command{printf}
to perform the conversion:
@example
-$ printf %x'\n' `seq -f %1.f 1048575 1024 1050623`
+$ printf '%x\n' `seq 1048575 1024 1050623`
fffff
1003ff
1007ff
@@ -13589,55 +13579,49 @@ For very long lists of numbers, use xargs to avoid
system limitations on the length of an argument list:
@example
-$ seq -f %1.f 1000000 | xargs printf %x'\n' | tail -n 3
+$ seq 1000000 | xargs printf '%x\n' | tail -n 3
f423e
f423f
f4240
@end example
To generate octal output, use the printf @code{%o} format instead
-of @code{%x}. Note however that using printf might not work for numbers
-outside the usual 32-bit range:
-
-@example
-$ printf "%x\n" `seq -f %1.f 4294967295 4294967296`
-ffffffff
-bash: printf: 4294967296: Numerical result out of range
-@end example
+of @code{%x}.
On most systems, seq can produce whole-number output for values up to
-@code{2^53}, so here's a more general approach to base conversion that
-also happens to be more robust for such large numbers. It works by
-using @code{bc} and setting its output radix variable, @var{obase},
-to @samp{16} in this case to produce hexadecimal output.
+at least @code{2^53}. Larger integers are approximated. The details
+differ depending on your floating-point implementation, but a common
+case is that @command{seq} works with integers through @code{2^64},
+and larger integers may not be numerically correct:
@example
-$ (echo obase=16; seq -f %1.f 4294967295 4294967296)|bc
-FFFFFFFF
-100000000
+$ seq 18446744073709551616 1 18446744073709551618
+18446744073709551616
+18446744073709551616
+18446744073709551618
@end example
-Be careful when using @command{seq} with a fractional @var{increment},
+Be careful when using @command{seq} with a fractional @var{increment};
otherwise you may see surprising results. Most people would expect to
-see @code{0.3} printed as the last number in this example:
+see @code{0.000003} printed as the last number in this example:
@example
-$ seq -s ' ' 0 .1 .3
-0 0.1 0.2
+$ seq -s ' ' 0 0.000001 0.000003
+0.000000 0.000001 0.000002
@end example
-But that doesn't happen on most systems because @command{seq} is
+But that doesn't happen on many systems because @command{seq} is
implemented using binary floating point arithmetic (via the C
-@code{double} type)---which means some decimal numbers like @code{.1}
+@code{long double} type)---which means decimal fractions like @code{0.000001}
cannot be represented exactly. That in turn means some nonintuitive
-conditions like @w{@code{.1 * 3 > .3}} will end up being true.
+conditions like @w{@code{0.000001 * 3 > 0.000003}} will end up being true.
To work around that in the above example, use a slightly larger number as
the @var{last} value:
@example
-$ seq -s ' ' 0 .1 .31
-0 0.1 0.2 0.3
+$ seq -s ' ' 0 0.000001 0.0000031
+0.000000 0.000001 0.000002 0.000003
@end example
In general, when using an @var{increment} with a fractional part, where