% jot(1) manual page
% Jessica L. Parsons (orc@pell.portland.or.us)
% Wed Sep 10 08:47:27 PDT 2008

###Name###
jot - print sequential or random data. 

###Synopsis###
`jot` `[-cnr]` `[-b` _word_`]` `[-w` _word_`]` `[-s` _separator_`]`
`[-p` _precision_`]` `[`_count_ `[`_begin_ `[`_end_ `[`_s_`]]]]`

###Description###
**Jot**
prints out increasing, decreasing, or random data, one item per
line. <P> The four arguments  _count_, _begin_, _end_, and  _s_
are the number of items to print, the starting point, the ending
point, and the step size.  While at least one of them must appear,
any of the other three may be omitted (giving _-_ counts) and will
be given default values.   The defaults for these arguments are
`count=100`, `begin=1`, `end=100`, and `s=1`. _count_ 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.

**Jot** takes the following options: 

=`-r`=
    Generate random data instead of sequential data.   If  _-r_ is
    given, the fourth argument is not used as a step size, but as
    a _seed_ for the random number generator, and it defaults to
    a random seed.

=`-b`_word_=
    Just print _word_ repetitively.

=`-w`_word_=
    Print _word_ with the generated data appended to it.   If the
    word contains a `printf(3)` conversion specification,
    the data is instead printed using that format.

=`-c`=
    This is an abbreviation for `-w`_c_.

=`-s`_separator_=
    Use  _separator_ between data elements instead of a newline.

=`-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 greated or the precisions of  _begin_ and _end_.  The
    `-p` option is overwritten by whatever appears in a `-w`
    argument.

###Examples###
1. The command `jot -b y 0` prints ``y'' forever. 

2. The ascii character set is generated with `jot -c 128 0`

3. The strings xaa through xaz with `jot -w xa%c 26 a`

4. The stuttering sequence 9, 9, 8, 8, 7, etc. can be produced by suitable
   choice of stepsize, as in `jot - 9 0 -.5` (the exact output
   depends on the vagaries of rounding;  on the FreeBSD machine I
   wrote this code on, this command produces `9, 8, 8, 7 ... 1, 1, 0`
   instead of the traditional jot behavior.)
 
###Diagnostics###
**Jot** returns with failure
status if an error occurs.   Most diagnostics are self-explanatory, but a
few need extra explanations:
 
=_illegal or unsupported format '%s'_=
    The requested conversion format for `-w` was not appropriate.
    It needs to be of the form 
	%[#] [ ] [{+,-}][0-9]*[.[0-9]*]?
    where  _?_ must be one of `[l]{d,i,io,u,x}` or `{c,e,f,g,D,E,G,O,U,X}`

=_impossible stepsize_=
    _begin_ is larger than _end_ but the step size is less than
    zero, or visa versa.

=_Too many conversions_=
    Only one conversion format is allowed in `-w`.


###Authors###
_Jessica L. Parsons_ <orc@pell.portland.or.us>  
The random number generator originally appeared in  _Toward a Universal
Random Number Generator_ by _George Marsaglia_ and _Arif Zaman_. Florida State
University Report: FSU-SCRI-87-50 (1987)