Hi guys, I have a slightly off-topic request. Would one of you be so kind and review a man page of a tool that I and a friend of mine have written recently and would like to include in Debian soon? We're basically done and about to make the 1.0 release but would like to see the man page be of better quality. With the upcoming release you all have much to do, I know that. I would still appreciate any help! I attached the asciidoc input file as well as the generated man page (for easier reading if you're unfamiliar with asciidoc). Thanks very much in advance! Hauke -- .''`. Jan Hauke Rahm <jhr@debian.org> www.jhr-online.de : :' : Debian Developer www.debian.org `. `'` Member of the Linux Foundation www.linux.com `- Fellow of the Free Software Foundation Europe www.fsfe.org
'\" t
.\" Title: enum
.\" Author: [see the "AUTHORS" section]
.\" Generator: DocBook XSL Stylesheets v1.75.2 <http://docbook.sf.net/>
.\" Date: 10/20/2010
.\" Manual: enum 0.4
.\" Source: enum 0.4
.\" Language: English
.\"
.TH "ENUM" "1" "10/20/2010" "enum 0\&.4" "enum 0\&.4"
.\" -----------------------------------------------------------------
.\" * Define some portability stuff
.\" -----------------------------------------------------------------
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.\" http://bugs.debian.org/507673
.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ie \n(.g .ds Aq \(aq
.el .ds Aq '
.\" -----------------------------------------------------------------
.\" * set default formatting
.\" -----------------------------------------------------------------
.\" disable hyphenation
.nh
.\" disable justification (adjust text to left margin only)
.ad l
.\" -----------------------------------------------------------------
.\" * MAIN CONTENT STARTS HERE *
.\" -----------------------------------------------------------------
.SH "NAME"
enum \- seq\- and jot\-like enumerator
.SH "SYNOPSIS"
.SS "GENERAL"
.sp
\fBenum\fR [ \fIOPTIONS\fR ] \fILEFT\fR "\&.\&." \fICOUNT\fR"x" \fISTEP\fR "\&.\&." \fIRIGHT\fR
.SS "SHORTCUTS"
.sp
\fBenum\fR [ \fIOPTIONS\fR ] \fILEFT\fR \fISTEP\fR \fIRIGHT\fR
.sp
\fBenum\fR [ \fIOPTIONS\fR ] \fILEFT\fR \fIRIGHT\fR
.sp
\fBenum\fR [ \fIOPTIONS\fR ] \fIRIGHT\fR
.sp
\&...
.SH "DESCRIPTION"
.sp
\fBenum\fR enumerates values (numbers) from \fILEFT\fR to \fIRIGHT\fR adding/subtracting \fISTEP\fR each time\&. If \fISTEP\fR is not provided it is implied\&. No more than \fICOUNT\fR values are printed\&. Before printing, values are passed through a formatter\&. Please see \fIOPTIONS\fR for details on controlling the formatter or \fIEXAMPLES\fR for use cases\&.
.sp
Further details on usage of \fBenum\fR are covered in \fIUSAGE IN DETAIL\fR\&.
.SH "EXAMPLES"
.SS "USE IN FOR\-LOOPS"
.sp
.if n \{\
.RS 4
.\}
.nf
for i in $(enum 1 3); do
touch file_${i}
done
.fi
.if n \{\
.RE
.\}
.SS "USE FOR RANDOM NUMBERS"
.sp
.if n \{\
.RS 4
.\}
.nf
number=$(enum \-\-random 3 \&.\&. 10)
.fi
.if n \{\
.RE
.\}
.sp
instead of native Bash like
.sp
.if n \{\
.RS 4
.\}
.nf
f() { min=$1; max=$2; echo $((RANDOM * (max \- min + 1) / 32767 + min)); }
number=$(f 3 10)
.fi
.if n \{\
.RE
.\}
.SS "SHOWING AN ASCII TABLE"
.sp
.if n \{\
.RS 4
.\}
.nf
enum \-f \*(Aq[%3i] "%c"\*(Aq 0 127
.fi
.if n \{\
.RE
.\}
.SH "OPTIONS"
.SS "RANDOM MODE"
.PP
\fB\-r, \-\-random\fR
.RS 4
Produces random numbers instead of monotone sequences, potentially with duplicates\&.
.RE
.PP
\fB\-i, \-\-seed\fR=\fINUMBER\fR
.RS 4
Pass
\fINUMBER\fR
as initializer to the random number generator\&. By default, the RNG is initialized from the current time and the process ID of the running instance of
\fBenum\fR\&.
.RE
.SS "FORMATTING"
.PP
\fB\-b, \-\-dumb\fR=\fITEXT\fR
.RS 4
Overrides the output format to
\fITEXT\fR
without interpolating placeholders\&. For instance,
\fBenum \-b "foo % 10" 3x\fR
produces the string "foo % 10" three times\&.
.RE
.PP
\fB\-c, \-\-characters\fR
.RS 4
Overrides the output format to
%c
producing characters\&. For example,
\fBenum \-c 65 67\fR
produces the letters "A", "B" and "C"\&.
.RE
.PP
\fB\-e, \-\-equal\-width\fR
.RS 4
Equalize width by padding with leading zeroes\&. NOTE: In case of mixed negative and non\-negative numbers (e\&.g\&. with
\fBenum \-e \(em \-10 1\fR), non\-negative values will compensate the lack of a leading minus with an extra zero to be of equal width\&.
.RE
.PP
\fB\-f, \-\-format\fR=\fIFORMAT\fR
.RS 4
Overrides the default output format with
\fIFORMAT\fR\&. For details on allowed formats please see printf(3)\&.
If
\fIFORMAT\fR
does not contain any placeholders,
\fBenum\fR
will error out with code 1\&. In contrast, jot would have appended the number\(cqs value instead\&. To make numbers appear at the end, please adjust
\fIFORMAT\fR
accordingly with
\fBenum\fR\&.
.RE
.PP
\fB\-l, \-\-one\-line\fR
.RS 4
Shortcut for "\fB\-s \*(Aq \*(Aq\fR" which means having a white space as separator instead of a new line\&.
.RE
.PP
\fB\-n, \-\-omit\-newline\fR
.RS 4
Omits the trailing newline from printing\&.
.RE
.PP
\fB\-p, \-\-precision\fR=\fICOUNT\fR
.RS 4
Overrides automatic selection of precision to print
\fICOUNT\fR
decimal places, e\&.g\&. "0\&.100" for
\fICOUNT\fR
= 3\&. By default, the number of digits to print is computed from the arguments given and the potentially computed step size\&.
.RE
.PP
\fB\-s, \-\-separator\fR=\fITEXT\fR
.RS 4
Overrides the separator that is printed between values\&. By default, values are separated by a newline\&.
.RE
.PP
\fB\-w, \-\-word\fR=\fIFORMAT\fR
.RS 4
Alias for \-\-format, copied from jot\&. For GNU seq\(cqs
\fB\-\-equal\-width\fR
shortcut
\fB\-w\fR
please see
\fB\-e\fR, instead\&.
.RE
.PP
\fB\-z, \-\-zero, \-\-null\fR
.RS 4
Print null bytes as separator, not a newline\&.
.RE
.SS "OTHER"
.PP
\fB\-h, \-\-help\fR
.RS 4
Outputs usage information and exits with code 0 (success)\&.
.RE
.PP
\fB\-V, \-\-version\fR
.RS 4
Displays version information and exits with code 0 (success)\&.
.RE
.SH "USAGE IN DETAIL"
.SS "INVOLVED ARGUMENTS"
.sp
Basically, the command line API looks like this:
.sp
\fBenum\fR [ \fIOPTIONS\fR ] \fILEFT\fR "\&.\&." \fICOUNT\fR"x" \fISTEP\fR "\&.\&." \fIRIGHT\fR
.sp
Four arguments are involved:
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fILEFT\fR, the value to start enumeration with
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fICOUNT\fR, the number of values to produce (in some cases less)
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fISTEP\fR, the gap from one value to another
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fIRIGHT\fR, the value to stop enumeration at (in some cases before)
.RE
.sp
Not all four arguments are needed, though specifying all four is possible\&. For a list of all valid combinations see \fIVALID COMBINATIONS\fR below\&. Details on derivation of defaults are addressed in \fIDERIVATION OF DEFAULTS\fR\&.
.SS "VALID COMBINATIONS"
.sp
With four arguments:
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
"\&.\&."
\fICOUNT\fR"x"
\fISTEP\fR
"\&.\&."
\fIRIGHT\fR
.RE
.sp
With three arguments:
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
\fICOUNT\fR"x"
\fIRIGHT\fR
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
"\&.\&."
\fICOUNT\fR"x"
\fISTEP\fR
"\&.\&."
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum "\&.\&."
\fICOUNT\fR"x"
\fISTEP\fR
"\&.\&."
\fIRIGHT\fR
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
"\&.\&."
\fICOUNT\fR"x" "\&.\&."
\fIRIGHT\fR
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
"\&.\&."
\fISTEP\fR
"\&.\&."
\fIRIGHT\fR
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
\fISTEP\fR
\fIRIGHT\fR
(for GNU seq compatibility)
.RE
.sp
With two arguments:
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum "\&.\&."
\fICOUNT\fR"x"
\fISTEP\fR
"\&.\&."
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum "\&.\&."
\fICOUNT\fR"x" "\&.\&."
\fIRIGHT\fR
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum "\&.\&."
\fISTEP\fR
"\&.\&."
\fIRIGHT\fR
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
"\&.\&."
\fICOUNT\fR"x" "\&.\&."
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
"\&.\&."
\fISTEP\fR
"\&.\&."
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
"\&.\&."
\fIRIGHT\fR
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
\fIRIGHT\fR
(for GNU seq compatibility)
.RE
.sp
With one argument:
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum "\&.\&."
\fISTEP\fR
"\&.\&."
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum "\&.\&."
\fICOUNT\fR"x" "\&.\&."
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum "\&.\&."
\fIRIGHT\fR
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fIRIGHT\fR
(for GNU seq compatibility)
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fILEFT\fR
"\&.\&."
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
enum
\fICOUNT\fR"x"
.RE
.sp
With less then three arguments, defaults apply\&. Details are described in \fIDERIVATION OF DEFAULTS\fR below\&.
.SS "DERIVATION OF DEFAULTS"
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBAUTO-SELECTION OF PRECISION\fR
.RS 4
.sp
\fBenum\fR distinguishes between "2", "2\&.0", "2\&.00" and so on:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum 1 2
1
2
# enum 1 2\&.0
1\&.0
1\&.1
[\&.\&.]
1\&.9
2\&.0
.fi
.if n \{\
.RE
.\}
.sp
Also, if the derived step has more decimal places than the specified values for \fILEFT\fR and \fIRIGHT\fR, the output precision will be raised to that of step
.sp
.if n \{\
.RS 4
.\}
.nf
# enum 1 \&.\&. 3x \&.\&. 2
1\&.0
1\&.5
2\&.0
.fi
.if n \{\
.RE
.\}
.sp
A specified precision always takes precedence:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \-p 2 1 \&.\&. 3x \&.\&. 2
1\&.00
1\&.50
2\&.00
.fi
.if n \{\
.RE
.\}
.RE
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBARGUMENT DEFAULTS\fR
.RS 4
.sp
In general, any three arguments are needed; three lead to the fourth\&. This equation brings them together:
.sp
\fILEFT\fR + (\fICOUNT\fR \- 1) * \fISTEP\fR = \fIRIGHT\fR
.sp
If you specify less than three of them (see \fIVALID COMBINATIONS\fR), the unspecified ones are derived or set to their defaults:
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fILEFT\fR
defaults to 1 (unless
\fISTEP\fR
and
\fIRIGHT\fR
are specified, see
\fIDERIVATION OF LEFT\fR
below)
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fICOUNT\fR
is infinity, unless it can be derived from the other three values\&.
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fISTEP\fR
defaults to 1, unless it can be derived\&.
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fIRIGHT\fR
is +/\-infinity, unless it can be derived from the other three values\&.
.RE
.RE
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBDERIVATION OF LEFT\fR
.RS 4
.sp
In general, \fILEFT\fR defaults to 1:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \&.\&. 3
1
2
3
.fi
.if n \{\
.RE
.\}
.sp
If \fISTEP\fR and \fIRIGHT\fR is given, it is derived as
.sp
\fILEFT\fR = \fIRIGHT\fR \- \fISTEP\fR * floor(\fIRIGHT\fR / \fISTEP\fR)
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \&.\&. 4 \&.\&. 10
2
6
10
.fi
.if n \{\
.RE
.\}
.sp
If, in addition to \fISTEP\fR and \fIRIGHT\fR, \fICOUNT\fR is given, it is derived as:
.sp
\fILEFT\fR = \fIRIGHT\fR \- (\fICOUNT\fR \- 1) * \fISTEP\fR
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \&.\&. 2x 4 \&.\&. 10
6
10
.fi
.if n \{\
.RE
.\}
.RE
.SS "GENERATION OF VALUES"
.sp
When a custom step is requested, values are produced as following:
.sp
.if n \{\
.RS 4
.\}
.nf
value[0] = LEFT + 0 * STEP
value[1] = LEFT + 1 * STEP
\&.\&.
value[i] = LEFT + i * STEP
.fi
.if n \{\
.RE
.\}
.sp
Else, to avoid imprecision adding up, values are produced as following:
.sp
.if n \{\
.RS 4
.\}
.nf
value[0] = LEFT + (RIGHT \- LEFT) / (COUNT \- 1) * 0
value[1] = LEFT + (RIGHT \- LEFT) / (COUNT \- 1) * 1
\&.\&.
value[i] = LEFT + (RIGHT \- LEFT) / (COUNT \- 1) * i
.fi
.if n \{\
.RE
.\}
.sp
Production stops when either \fICOUNT\fR values have been produced or \fIRIGHT\fR has been reached, whichever hits first\&. When all 4 values are given in perfect match they hit at the same time\&.
.SH "RANDOM MODE"
.sp
Basically, random mode differs in these regards:
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
Produced values are random\&.
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
Argument
\fICOUNT\fR
defaults to 1 (one)\&.
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
Argument
\fILEFT\fR
(always!) defaults to 1 (one)\&.
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
Argument
\fIRIGHT\fR
is required: Random does not mix with infinity\&.
.RE
.sp
We will now cover these differences in detail\&.
.SS "COUNT DEFAULTS TO 1 (ONE)"
.sp
In random mode only one value is produced, by default:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum 1 4
1
2
3
4
# enum \-r 1 4
3
.fi
.if n \{\
.RE
.\}
.sp
By specifying count you can produce more values at a time:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \-r 1 \&.\&. 3x \&.\&. 4
2
1
3
.fi
.if n \{\
.RE
.\}
.SS "LEFT ALWAYS DEFAULTS TO 1 (ONE)"
.sp
When you need increasing numbers up to a certain maximum (say 10), each apart by a certain step (say 4) you can let \fBenum\fR calculate the needed starting value for you:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \&.\&. 4 \&.\&. 10
2
6
10
.fi
.if n \{\
.RE
.\}
.sp
In random mode \fILEFT\fR is never calculated and defaults to 1 (one):
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \-r \&.\&. 5x 4 \&.\&. 10
1
1
9
1
5
.fi
.if n \{\
.RE
.\}
.SS "RANDOM DOES NOT MIX WITH INFINITY"
.sp
In general, \fBenum\fR supports running towards infinity:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum 1 \&.\&. 2\&.0 \&.\&.
1\&.0
3\&.0
5\&.0
[\&.\&.]
.fi
.if n \{\
.RE
.\}
.sp
However, in random mode \fBenum\fR would now produce random numbers from 1 to infinity (or a big number like \fIFLT_MAX\fR from \fI<float\&.h>\fR), which we have decided against\&.
.SH "HISTORY"
.sp
\fBenum\fR is a fusion of GNU seq and jot, feature\-wise\&. At the core both tools print sequences of numbers\&. GNU seq has a clean interface but very limited functionality\&. jot on the other hand offers more advanced features, like producing random numbers, at the cost of a rather unfriendly interface\&.
.sp
With \fBenum\fR we try to offer a tool with the power of jot and a usable, easily memorable interface\&. \fBenum\fR is licensed under a BSD license and written in C89 for maximum portability\&.
.sp
In the following sections we will take a look at differences in detail\&.
.SH "COMPARISON TO JOT"
.sp
Using \fBenum\fR instead of jot offers two main advantages:
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
improved usability and
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
uniform behavior across distributions and operating systems\&.
.RE
.sp
Still (as of 2010\-10\-03), jot implementations differ subtly among DragonFlyBSD, FreeBSD, MirOS BSD, NetBSD, OpenBSD and OS X\&. For instance the command \fIjot \- 0 5\fR produces
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
6 integers from 0 to 5 on FreeBSD and OS X,
.sp
.if n \{\
.RS 4
.\}
.nf
0 1 2 3 4 5
.fi
.if n \{\
.RE
.\}
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
100 integers from 0 to 99 on NetBSD, and
.sp
.if n \{\
.RS 4
.\}
.nf
0 1 2 [\&.\&.] 97 98 99
.fi
.if n \{\
.RE
.\}
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
100 integers from 0 to 5 (with consecutive duplicates) on DragonFlyBSD, MirOS BSD and OpenBSD\&.
.sp
.if n \{\
.RS 4
.\}
.nf
0 0 0 0 0 0 0 0 0 0 1 1 [\&.\&.] 4 4 5 5 5 5 5 5 5 5 5 5
.fi
.if n \{\
.RE
.\}
.RE
.sp
Basically, the full feature set of jot plus a few enhancements is contained in \fBenum\fR\&. Names of parameters have been retained for increased compatibility, e\&.g\&. \fB\-p 2\fR works with \fBenum\fR as it does with jot:
.sp
.if n \{\
.RS 4
.\}
.nf
# jot \-p 2 3
1\&.00
2\&.00
3\&.00
# enum \-p 2 3
1\&.00
2\&.00
3\&.00
.fi
.if n \{\
.RE
.\}
.sp
Please see OPTIONS above for further details\&.
.SS "ADDITIONAL FEATURES"
.sp
The features that \fBenum\fR offers over jot include:
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBMORE MEMORABLE COMMAND LINE USAGE\fR
.RS 4
.sp
In order to produce 3 random numbers between 1 and 10 inclusively, you would run
.sp
.if n \{\
.RS 4
.\}
.nf
jot \-r 3 1 10
.fi
.if n \{\
.RE
.\}
.sp
with jot\&. We find these alternative calls to \fBenum\fR more intuitive:
.sp
.if n \{\
.RS 4
.\}
.nf
enum \-r 1 \&.\&. 3x \&.\&. 10
enum \-r 1 3x 10
.fi
.if n \{\
.RE
.\}
.RE
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBCUSTOM RESOLUTION OF RANDOM\fR
.RS 4
.sp
With \fBenum\fR you can specify the gap between possible random values\&. These two cases illustrate the difference between a gap of 2 and 3:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \-r 4 \&.\&. 100x 2 \&.\&. 10 | sort \-u \-n
4
6
8
10
# enum \-r 4 \&.\&. 100x 3 \&.\&. 10 | sort \-u \-n
4
7
10
.fi
.if n \{\
.RE
.\}
.RE
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBSUPPORT FOR SEVERAL PLACEHOLDERS IN FORMAT STRINGS\fR
.RS 4
.sp
jot on DragonFlyBSD, FreeBSD, MirOS BSD, OpenBSD and OS X:
.sp
.if n \{\
.RS 4
.\}
.nf
# jot \-w %g%g 3
jot: too many conversions
.fi
.if n \{\
.RE
.\}
.sp
jot on NetBSD:
.sp
.if n \{\
.RS 4
.\}
.nf
# jot \-w %g%g 3
jot: unknown or invalid format `%g%g\*(Aq
.fi
.if n \{\
.RE
.\}
.sp
\fBenum\fR on any platform:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \-f %g%g 3
11
22
33
.fi
.if n \{\
.RE
.\}
.RE
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBNULL BYTES AS SEPARATOR\fR
.RS 4
.sp
When using format strings containing spaces, you may run into trouble in contexts like for loops or xargs: Spaces are treated as separators which breaks up your strings in pieces:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \-f \*(Aqsheep number %d\*(Aq 2 | xargs \-n 1 echo
sheep
number
1
sheep
number
2
.fi
.if n \{\
.RE
.\}
.sp
To prevent this, you could pass \fB\-\-null\fR to both \fBenum\fR and xargs:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \-\-null \-f \*(Aqsheep number %d\*(Aq 2 | xargs \-\-null \-n 1 echo
sheep number 1
sheep number 2
.fi
.if n \{\
.RE
.\}
.RE
.SS "DIFFERENCES"
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBHANDLING OF FORMATS WITHOUT PLACEHOLDERS\fR
.RS 4
.sp
In contrast to jot, \fBenum\fR does not append the current value, if the formatting string does not contain a placeholder\&. Behavior of jot:
.sp
.if n \{\
.RS 4
.\}
.nf
# jot 3 \-w test_
test_1
test_2
test_3
.fi
.if n \{\
.RE
.\}
.sp
Behavior of \fBenum\fR:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \-w test_ 3
test_
test_
test_
.fi
.if n \{\
.RE
.\}
.sp
In order to achieve jot\(cqs output with \fBenum\fR, you could manually append a placeholder:
.sp
.if n \{\
.RS 4
.\}
.nf
# enum \-w test_%d 3
test_1
test_2
test_3
.fi
.if n \{\
.RE
.\}
.RE
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBNON-NUMBER VALUES FOR LEFT AND RIGHT\fR
.RS 4
.sp
\fBenum\fR does not support using ASCII characters instead of their numerical values (e\&.g\&. "A" for 65) for \fILEFT\fR and \fIRIGHT\fR\&. With jot you can do:
.sp
.if n \{\
.RS 4
.\}
.nf
# jot 3 A
65
66
67
.fi
.if n \{\
.RE
.\}
.sp
Inconsistently,
.sp
.if n \{\
.RS 4
.\}
.nf
# jot 3 0
0
1
2
.fi
.if n \{\
.RE
.\}
.sp
jot does not interpret "0" as ASCII character with code 48\&. We have no intention duplicating this mix, at the moment\&.
.RE
.SH "COMPARISON TO GNU SEQ"
.sp
Basically, \fBenum\fR\*(Aqs usage is backwards\-compatible to that of GNU seq\&.
.SS "ADDITIONAL FEATURES"
.sp
The features \fBenum\fR offers over GNU seq include:
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBRANDOM NUMBER MODE\fR
.RS 4
.sp
\fBenum\fR supports output of constrained random numbers, e\&.g\&.
.sp
.if n \{\
.RS 4
.\}
.nf
enum \-r 4 \&.\&. 3x 2\&.0 \&.\&. 11
.fi
.if n \{\
.RE
.\}
.sp
produces three (possibly duplicate) random numbers from the set {4\&.0, 6\&.0, 8\&.0, 10\&.0}\&.
.RE
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBSUPPORT FOR INVERSE ORDERING\fR
.RS 4
.sp
In contrast to GNU seq, \fBenum\fR supports enumerating decreasing values:
.sp
.if n \{\
.RS 4
.\}
.nf
# seq 3 1
# enum 3 1
3
2
1
.fi
.if n \{\
.RE
.\}
.RE
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBSUPPORT FOR SEVERAL PLACEHOLDERS IN FORMAT STRINGS\fR
.RS 4
.sp
.if n \{\
.RS 4
.\}
.nf
# seq \-f %g%g 3
seq: format `%g%g\*(Aq has too many % directives
# enum \-f %g%g 3
11
22
33
.fi
.if n \{\
.RE
.\}
.RE
.sp
.it 1 an-trap
.nr an-no-space-flag 1
.nr an-break-flag 1
.br
.ps +1
\fBOMITTING FINAL NEWLINE\fR
.RS 4
.sp
By specifying \fB\-n\fR as a parameter, you can make \fBenum\fR omit the trailing newline\&.
.RE
.SS "DIFFERENCES"
.sp
GNU seq\(cqs \fB\-\-equal\-width\fR shortcut \fB\-w\fR conflicts with jot\(cqs \fB\-w word\fR\&. We chose to make \fB\-e\fR the shortcut for \fB\-\-equal\-width\fR in \fBenum\fR, instead\&.
.sp
Also, while GNU seq is licensed under GPL v3 or later, \fBenum\fR is licensed under the New BSD license\&.
.SH "AUTHORS"
.sp
Jan Hauke Rahm <jhr@debian\&.org>
.sp
Sebastian Pipping <sping@gentoo\&.org>
.SH "RESOURCES"
.sp
Main web site: https://fedorahosted\&.org/enum/
.sp
Gitweb: http://git\&.fedorahosted\&.org/git/?p=enum\&.git
.SH "SEE ALSO"
.sp
jot(1), seq(1), printf(3), float\&.h(0p)
ENUM(1)
=======
:man source: enum {enumversion}
:man manual: enum {enumversion}
NAME
----
enum - seq- and jot-like enumerator
SYNOPSIS
--------
GENERAL
~~~~~~~
*enum* [ 'OPTIONS' ] 'LEFT' ".." 'COUNT'"x" 'STEP' ".." 'RIGHT'
SHORTCUTS
~~~~~~~~~
*enum* [ 'OPTIONS' ] 'LEFT' 'STEP' 'RIGHT'
*enum* [ 'OPTIONS' ] 'LEFT' 'RIGHT'
*enum* [ 'OPTIONS' ] 'RIGHT'
...
DESCRIPTION
-----------
*enum* enumerates values (numbers) from 'LEFT' to 'RIGHT'
adding/subtracting 'STEP' each time. If 'STEP' is not provided it is
implied. No more than 'COUNT' values are printed. Before printing,
values are passed through a formatter. Please see 'OPTIONS' for
details on controlling the formatter or 'EXAMPLES' for use cases.
Further details on usage of *enum* are covered in 'USAGE IN DETAIL'.
EXAMPLES
--------
USE IN FOR-LOOPS
~~~~~~~~~~~~~~~~
--------------------------------------
for i in $(enum 1 3); do
touch file_${i}
done
--------------------------------------
USE FOR RANDOM NUMBERS
~~~~~~~~~~~~~~~~~~~~~~
--------------------------------------
number=$(enum --random 3 .. 10)
--------------------------------------
instead of native Bash like
--------------------------------------
f() { min=$1; max=$2; echo $((RANDOM * (max - min + 1) / 32767 + min)); }
number=$(f 3 10)
--------------------------------------
SHOWING AN ASCII TABLE
~~~~~~~~~~~~~~~~~~~~~~
--------------------------------------
enum -f '[%3i] "%c"' 0 127
--------------------------------------
OPTIONS
-------
RANDOM MODE
~~~~~~~~~~~
*-r, --random*::
Produces random numbers instead of monotone sequences,
potentially with duplicates.
*-i, --seed*='NUMBER'::
Pass 'NUMBER' as initializer to the random number generator.
By default, the RNG is initialized from the current time and
the process ID of the running instance of *enum*.
FORMATTING
~~~~~~~~~~
*-b, --dumb*='TEXT'::
Overrides the output format to 'TEXT' without interpolating
placeholders. For instance, *enum -b "foo % 10" 3x* produces
the string "foo % 10" three times.
*-c, --characters*::
Overrides the output format to `%c` producing characters.
For example, *enum -c 65 67* produces the letters "A", "B" and "C".
*-e, --equal-width*::
Equalize width by padding with leading zeroes.
NOTE: In case of mixed negative and non-negative numbers
(e.g. with *enum -e -- -10 1*), non-negative values will compensate
the lack of a leading minus with an extra zero to be of equal width.
*-f, --format*='FORMAT'::
Overrides the default output format with 'FORMAT'.
For details on allowed formats please see printf(3). +
If 'FORMAT' does not contain any placeholders, *enum* will error out
with code 1. In contrast, jot would have appended the number's
value instead. To make numbers appear at the end, please adjust
'FORMAT' accordingly with *enum*.
*-l, --one-line*::
Shortcut for "*-s ' '*" which means having a white space as separator
instead of a new line.
*-n, --omit-newline*::
Omits the trailing newline from printing.
*-p, --precision*='COUNT'::
Overrides automatic selection of precision to print 'COUNT'
decimal places, e.g. "0.100" for 'COUNT' = 3.
By default, the number of digits to print is computed from the
arguments given and the potentially computed step size.
*-s, --separator*='TEXT'::
Overrides the separator that is printed between values.
By default, values are separated by a newline.
*-w, --word*='FORMAT'::
Alias for --format, copied from jot.
For GNU seq's *--equal-width* shortcut *-w* please see *-e*, instead.
*-z, --zero, --null*::
Print null bytes as separator, not a newline.
OTHER
~~~~~
*-h, --help*::
Outputs usage information and exits with code 0 (success).
*-V, --version*::
Displays version information and exits with code 0 (success).
USAGE IN DETAIL
---------------
INVOLVED ARGUMENTS
~~~~~~~~~~~~~~~~~~
Basically, the command line API looks like this:
*enum* [ 'OPTIONS' ] 'LEFT' ".." 'COUNT'"x" 'STEP' ".." 'RIGHT'
Four arguments are involved:
- 'LEFT', the value to start enumeration with
- 'COUNT', the number of values to produce (in some cases less)
- 'STEP', the gap from one value to another
- 'RIGHT', the value to stop enumeration at (in some cases before)
Not all four arguments are needed, though specifying all four is possible.
For a list of all valid combinations see 'VALID COMBINATIONS' below.
Details on derivation of defaults are addressed in 'DERIVATION OF DEFAULTS'.
VALID COMBINATIONS
~~~~~~~~~~~~~~~~~~
With four arguments:
- enum 'LEFT' ".." 'COUNT'"x" 'STEP' ".." 'RIGHT'
With three arguments:
- enum 'LEFT' 'COUNT'"x" 'RIGHT'
- enum 'LEFT' ".." 'COUNT'"x" 'STEP' ".."
- enum ".." 'COUNT'"x" 'STEP' ".." 'RIGHT'
- enum 'LEFT' ".." 'COUNT'"x" ".." 'RIGHT'
- enum 'LEFT' ".." 'STEP' ".." 'RIGHT'
- enum 'LEFT' 'STEP' 'RIGHT' (for GNU seq compatibility)
With two arguments:
- enum ".." 'COUNT'"x" 'STEP' ".."
- enum ".." 'COUNT'"x" ".." 'RIGHT'
- enum ".." 'STEP' ".." 'RIGHT'
- enum 'LEFT' ".." 'COUNT'"x" ".."
- enum 'LEFT' ".." 'STEP' ".."
- enum 'LEFT' ".." 'RIGHT'
- enum 'LEFT' 'RIGHT' (for GNU seq compatibility)
With one argument:
- enum ".." 'STEP' ".."
- enum ".." 'COUNT'"x" ".."
- enum ".." 'RIGHT'
- enum 'RIGHT' (for GNU seq compatibility)
- enum 'LEFT' ".."
- enum 'COUNT'"x"
With less then three arguments, defaults apply.
Details are described in 'DERIVATION OF DEFAULTS' below.
DERIVATION OF DEFAULTS
~~~~~~~~~~~~~~~~~~~~~~
AUTO-SELECTION OF PRECISION
^^^^^^^^^^^^^^^^^^^^^^^^^^^
*enum* distinguishes between "2", "2.0", "2.00" and so on:
--------------------------------------
# enum 1 2
1
2
# enum 1 2.0
1.0
1.1
[..]
1.9
2.0
--------------------------------------
Also, if the derived step has more decimal places than the
specified values for 'LEFT' and 'RIGHT', the output precision
will be raised to that of step
--------------------------------------
# enum 1 .. 3x .. 2
1.0
1.5
2.0
--------------------------------------
A specified precision always takes precedence:
--------------------------------------
# enum -p 2 1 .. 3x .. 2
1.00
1.50
2.00
--------------------------------------
ARGUMENT DEFAULTS
^^^^^^^^^^^^^^^^^
In general, any three arguments are needed; three lead to the fourth.
This equation brings them together:
'LEFT' + ('COUNT' - 1) * 'STEP' = 'RIGHT'
If you specify less than three of them (see 'VALID COMBINATIONS'), the
unspecified ones are derived or set to their defaults:
- 'LEFT' defaults to 1 (unless 'STEP' and 'RIGHT' are specified, see
'DERIVATION OF LEFT' below)
- 'COUNT' is infinity, unless it can be derived from the other three values.
- 'STEP' defaults to 1, unless it can be derived.
- 'RIGHT' is +/-infinity, unless it can be derived from the other three
values.
DERIVATION OF LEFT
^^^^^^^^^^^^^^^^^^
In general, 'LEFT' defaults to 1:
--------------------------------------
# enum .. 3
1
2
3
--------------------------------------
If 'STEP' and 'RIGHT' is given, it is derived as
'LEFT' = 'RIGHT' - 'STEP' * floor('RIGHT' / 'STEP')
--------------------------------------
# enum .. 4 .. 10
2
6
10
--------------------------------------
If, in addition to 'STEP' and 'RIGHT', 'COUNT' is given, it is derived as:
'LEFT' = 'RIGHT' - ('COUNT' - 1) * 'STEP'
--------------------------------------
# enum .. 2x 4 .. 10
6
10
--------------------------------------
GENERATION OF VALUES
~~~~~~~~~~~~~~~~~~~~
When a custom step is requested, values are produced as following:
value[0] = LEFT + 0 * STEP
value[1] = LEFT + 1 * STEP
..
value[i] = LEFT + i * STEP
Else, to avoid imprecision adding up, values are produced as following:
value[0] = LEFT + (RIGHT - LEFT) / (COUNT - 1) * 0
value[1] = LEFT + (RIGHT - LEFT) / (COUNT - 1) * 1
..
value[i] = LEFT + (RIGHT - LEFT) / (COUNT - 1) * i
Production stops when either 'COUNT' values have been produced or 'RIGHT'
has been reached, whichever hits first. When all 4 values are given in
perfect match they hit at the same time.
RANDOM MODE
-----------
Basically, random mode differs in these regards:
- Produced values are random.
- Argument 'COUNT' defaults to 1 (one).
- Argument 'LEFT' (always!) defaults to 1 (one).
- Argument 'RIGHT' is required: Random does not mix with infinity.
We will now cover these differences in detail.
COUNT DEFAULTS TO 1 (ONE)
~~~~~~~~~~~~~~~~~~~~~~~~~
In random mode only one value is produced, by default:
--------------------------------------
# enum 1 4
1
2
3
4
# enum -r 1 4
3
--------------------------------------
By specifying count you can produce more values at a time:
--------------------------------------
# enum -r 1 .. 3x .. 4
2
1
3
--------------------------------------
LEFT ALWAYS DEFAULTS TO 1 (ONE)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When you need increasing numbers up to a certain maximum (say 10),
each apart by a certain step (say 4) you can let *enum* calculate
the needed starting value for you:
--------------------------------------
# enum .. 4 .. 10
2
6
10
--------------------------------------
In random mode 'LEFT' is never calculated and defaults to 1 (one):
--------------------------------------
# enum -r .. 5x 4 .. 10
1
1
9
1
5
--------------------------------------
RANDOM DOES NOT MIX WITH INFINITY
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In general, *enum* supports running towards infinity:
--------------------------------------
# enum 1 .. 2.0 ..
1.0
3.0
5.0
[..]
--------------------------------------
However, in random mode *enum* would now produce random numbers from 1 to
infinity (or a big number like 'FLT_MAX' from '<float.h>'), which we have
decided against.
HISTORY
-------
*enum* is a fusion of GNU seq and jot, feature-wise. At the core both tools
print sequences of numbers. GNU seq has a clean interface but very limited
functionality. jot on the other hand offers more advanced features, like
producing random numbers, at the cost of a rather unfriendly interface.
With *enum* we try to offer a tool with the power of jot and a usable,
easily memorable interface. *enum* is licensed under a BSD license and
written in C89 for maximum portability.
In the following sections we will take a look at differences in detail.
COMPARISON TO JOT
-----------------
Using *enum* instead of jot offers two main advantages:
- improved usability and
- uniform behavior across distributions and operating systems.
Still (as of 2010-10-03), jot implementations differ subtly among
DragonFlyBSD, FreeBSD, MirOS BSD, NetBSD, OpenBSD and OS X. For
instance the command 'jot - 0 5' produces
- 6 integers from 0 to 5 on FreeBSD and OS X,
0 1 2 3 4 5
- 100 integers from 0 to 99 on NetBSD, and
0 1 2 [..] 97 98 99
- 100 integers from 0 to 5 (with consecutive duplicates) on
DragonFlyBSD, MirOS BSD and OpenBSD.
0 0 0 0 0 0 0 0 0 0 1 1 [..] 4 4 5 5 5 5 5 5 5 5 5 5
Basically, the full feature set of jot plus a few enhancements is contained
in *enum*. Names of parameters have been retained for increased
compatibility, e.g. *-p 2* works with *enum* as it does with jot:
--------------------------------------
# jot -p 2 3
1.00
2.00
3.00
# enum -p 2 3
1.00
2.00
3.00
--------------------------------------
Please see OPTIONS above for further details.
ADDITIONAL FEATURES
~~~~~~~~~~~~~~~~~~~
The features that *enum* offers over jot include:
MORE MEMORABLE COMMAND LINE USAGE
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
In order to produce 3 random numbers between 1 and 10 inclusively, you
would run
--------------------------------------
jot -r 3 1 10
--------------------------------------
with jot. We find these alternative calls to *enum* more intuitive:
--------------------------------------
enum -r 1 .. 3x .. 10
enum -r 1 3x 10
--------------------------------------
CUSTOM RESOLUTION OF RANDOM
^^^^^^^^^^^^^^^^^^^^^^^^^^^
With *enum* you can specify the gap between possible random values.
These two cases illustrate the difference between a gap of 2 and 3:
--------------------------------------
# enum -r 4 .. 100x 2 .. 10 | sort -u -n
4
6
8
10
# enum -r 4 .. 100x 3 .. 10 | sort -u -n
4
7
10
--------------------------------------
SUPPORT FOR SEVERAL PLACEHOLDERS IN FORMAT STRINGS
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
jot on DragonFlyBSD, FreeBSD, MirOS BSD, OpenBSD and OS X:
--------------------------------------
# jot -w %g%g 3
jot: too many conversions
--------------------------------------
jot on NetBSD:
--------------------------------------
# jot -w %g%g 3
jot: unknown or invalid format `%g%g'
--------------------------------------
*enum* on any platform:
--------------------------------------
# enum -f %g%g 3
11
22
33
--------------------------------------
NULL BYTES AS SEPARATOR
^^^^^^^^^^^^^^^^^^^^^^^
When using format strings containing spaces, you may run into trouble in
contexts like for loops or xargs: Spaces are treated as separators which
breaks up your strings in pieces:
--------------------------------------
# enum -f 'sheep number %d' 2 | xargs -n 1 echo
sheep
number
1
sheep
number
2
--------------------------------------
To prevent this, you could pass *--null* to both *enum* and xargs:
--------------------------------------
# enum --null -f 'sheep number %d' 2 | xargs --null -n 1 echo
sheep number 1
sheep number 2
--------------------------------------
DIFFERENCES
~~~~~~~~~~~
HANDLING OF FORMATS WITHOUT PLACEHOLDERS
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
In contrast to jot, *enum* does not append the current value, if the
formatting string does not contain a placeholder.
Behavior of jot:
--------------------------------------
# jot 3 -w test_
test_1
test_2
test_3
--------------------------------------
Behavior of *enum*:
--------------------------------------
# enum -w test_ 3
test_
test_
test_
--------------------------------------
In order to achieve jot's output with *enum*, you could manually
append a placeholder:
--------------------------------------
# enum -w test_%d 3
test_1
test_2
test_3
--------------------------------------
NON-NUMBER VALUES FOR LEFT AND RIGHT
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
*enum* does not support using ASCII characters instead of their
numerical values (e.g. "A" for 65) for 'LEFT' and 'RIGHT'.
With jot you can do:
--------------------------------------
# jot 3 A
65
66
67
--------------------------------------
Inconsistently,
--------------------------------------
# jot 3 0
0
1
2
--------------------------------------
jot does not interpret "0" as ASCII character with code 48.
We have no intention duplicating this mix, at the moment.
COMPARISON TO GNU SEQ
---------------------
Basically, *enum*'s usage is backwards-compatible to that of GNU seq.
ADDITIONAL FEATURES
~~~~~~~~~~~~~~~~~~~
The features *enum* offers over GNU seq include:
RANDOM NUMBER MODE
^^^^^^^^^^^^^^^^^^
*enum* supports output of constrained random numbers, e.g.
--------------------------------------
enum -r 4 .. 3x 2.0 .. 11
--------------------------------------
produces three (possibly duplicate) random numbers
from the set {4.0, 6.0, 8.0, 10.0}.
SUPPORT FOR INVERSE ORDERING
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
In contrast to GNU seq, *enum* supports enumerating decreasing values:
--------------------------------------
# seq 3 1
# enum 3 1
3
2
1
--------------------------------------
SUPPORT FOR SEVERAL PLACEHOLDERS IN FORMAT STRINGS
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
--------------------------------------
# seq -f %g%g 3
seq: format `%g%g' has too many % directives
# enum -f %g%g 3
11
22
33
--------------------------------------
OMITTING FINAL NEWLINE
^^^^^^^^^^^^^^^^^^^^^^
By specifying *-n* as a parameter, you can make *enum* omit the
trailing newline.
DIFFERENCES
~~~~~~~~~~~
GNU seq's *--equal-width* shortcut *-w* conflicts with jot's *-w word*.
We chose to make *-e* the shortcut for *--equal-width* in *enum*, instead.
Also, while GNU seq is licensed under GPL v3 or later, *enum* is
licensed under the New BSD license.
AUTHORS
-------
Jan Hauke Rahm <jhr@debian.org>
Sebastian Pipping <sping@gentoo.org>
RESOURCES
---------
Main web site: https://fedorahosted.org/enum/
Gitweb: http://git.fedorahosted.org/git/?p=enum.git
SEE ALSO
--------
jot(1), seq(1), printf(3), float.h(0p)
Attachment:
signature.asc
Description: Digital signature