jot - print sequential or random data
jot [-cnr] [-b word] [-p precision] [-s string] [-w word]
[reps [begin [end [s]]]]
jot is used to print out increasing, decreasing, random, or
redundant data,
usually numbers, one per line.
The options are as follows:
-b word Just print word repetitively.
-c This is an abbreviation for -w %c.
-n Do not print the final newline normally appended to the
output.
-p precision Print only as many digits or characters of the
data as indicated
by the integer precision. In the absence of -p,
the precision is the greater of the numbers
begin and end.
The -p option is overridden by whatever appears in a
printf(3) conversion following -w.
-r Generate random data. By default, jot generates sequential
data.
-s string Print data separated by string. Normally,
newlines separate
data.
-w word Print word with the generated data appended to
it. Octal,
hexadecimal, exponential, ASCII, zero-padded,
and right-adjusted
representations are possible by using
the appropriate
printf(3) conversion specification inside
word, in
which case the data is inserted rather than
appended.
The last four arguments indicate, respectively, the maximum
number of data,
the lower bound, the upper bound, and the step size.
While at least
one of them must appear, any of the other three may be omitted, and will
be considered as such if given as `-'. Any three of these
arguments determines
the fourth. If four are specified and the given
and computed
values of reps conflict, the lower value is used. If fewer
than three
are specified, defaults are assigned left to right, except
for s, which
assumes its default unless both begin and end are given.
Defaults for the four arguments are, respectively, 100, 1,
100, and 1.
reps is expected to be an unsigned integer, and if given as
zero is taken
to be infinite. begin and end may be given as real numbers
or as characters
representing the corresponding value in ASCII. The
last argument
must be a real number.
Random numbers are obtained through arc4random(3). Historical versions
of jot used s to seed the random number generator. This is
no longer
supported. The name jot derives in part from iota, a function in APL.
Rounding and truncation [Toc] [Back]
The jot utility uses double precision floating point arithmetic internally.
Before printing a number, it is converted depending on
the output
format used.
If no output format is specified or the output format is a
floating point
format (`f', `e', `g', `E', or `G'), the value is rounded
using the
printf(3) function, taking into account the requested precision.
If the output format is an integer format (`c', `d', `o',
`x', `u', `D',
`O', `X', `U', or `i'), the value is converted to an integer
value by
truncation.
As an illustration, consider the following command:
$ jot 6 1 10 0.5
1
2
2
2
3
4
By requesting an explicit precision of 1, the values generated before
rounding can be seen. The .5 values are rounded down if the
integer part
is even, up otherwise.
$ jot -p 1 6 1 10 0.5
1.0
1.5
2.0
2.5
3.0
3.5
By offsetting the values slightly, the values generated by
the following
command are always rounded down:
$ jot -p 0 6 .9999999999 10 0.5
1
1
2
2
3
3
Another way of achieving the same result is to force truncation by specifying
an integer format:
$ jot -w %d 6 1 10 0.5
For random sequences, the output format also influences the
range and
distribution of the generated numbers:
$ jot -r 100000 1 3 | sort -n | uniq -c
24950 1
50038 2
25012 3
The values at the beginning and end of the interval are generated less
frequently than the other values. There are several ways to
solve this
problem and generate evenly distributed integers:
$ jot -r -p 0 100000 0.5 3.5 | sort -n | uniq -c
33374 1
33363 2
33263 3
$ jot -w %d -r 100000 1 4 | sort -n | uniq -c
33306 1
33473 2
33221 3
Note that with random sequences, all numbers generated will
be smaller
than the upper bound. The largest value generated will be a
tiny bit
smaller than the upper bound. For floating point formats,
the value is
rounded as described before being printed. For integer formats, the
highest value printed will be one less than the requested
upper bound,
because the generated value will be truncated.
Print 21 evenly spaced numbers increasing from -1 to 1:
$ jot 21 -1 1.00
Generate the ASCII character set:
$ jot -c 128 0
Generate the strings xaa through xaz:
$ jot -w xa%c 26 a
Generate 20 random 8-letter strings (note that the character
`{' comes
after the character `z' in the ASCII character set):
$ jot -r -c 160 a { | rs -g 0 8
Infinitely many yes(1)'s may be obtained through:
$ jot -b yes 0
Thirty ed(1) substitution commands applying to lines 2, 7,
12, etc. is
the result of:
$ jot -w %ds/old/new/ 30 2 - 5
Create a file containing exactly 1024 bytes:
$ jot -b x 512 > block
To set tabs four spaces apart starting from column 10 and
ending in column
132, use:
$ expand -`jot -s, - 10 132 4`
To print all lines 80 characters or longer:
$ grep `jot -s "" -b. 80`
ed(1), expand(1), rs(1), yes(1), arc4random(3), printf(3)
OpenBSD 3.6 June 6, 1993
[ Back ] |
