for i in $(enum -e 1 20); do


    touch file_${i}
done

number=$(enum --random 3 .. 10)

f() { min=$1; max=$2; echo $((RANDOM * (max - min + 1) / 32767 + min)); }
number=$(f 3 10)

enum -f '[%3i] "%c"' 0 127

FORMAT is subject to processing of C escape sequences (e.g. "\n" makes a newline). If FORMAT does not contain any placeholders, enum will print FORMAT repeatedly. In contrast, jot would have appended the number’s value instead. To make numbers appear at the end with enum, adjust FORMAT appropriately.

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 the step value:

# enum 1 .. 3x .. 2
1.0
1.5
2.0

A specified precision always takes precedence, though:

# enum -p 2 1 .. 3x .. 2
1.00
1.50
2.00

In general, three arguments are needed; any three imply 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:

Obviously, if COUNT is set to zero (0x), enum will output nothing, regardless of the other arguments.

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

value[0] = LEFT + 0 * STEP
value[1] = LEFT + 1 * STEP
..
value[i] = LEFT + i * STEP

value[0] = LEFT + (RIGHT - LEFT) / (COUNT - 1) * 0
value[1] = LEFT + (RIGHT - LEFT) / (COUNT - 1) * 1
..
value[i] = LEFT + (RIGHT - LEFT) / (COUNT - 1) * i

# enum 1 4
1
2
3
4
# enum -r 1 4
3

# enum -r 1 .. 3x .. 4
2
1
3

# enum .. 4 .. 10
2
6
10

# enum -r .. 5x 4 .. 10
1
1
9
1
5

# enum 1 .. 2.0 ..
1.0
3.0
5.0
[..]

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

With enum you can specify that the possible values to be randomly selected from have a particular spacing. 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

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

None of the jot implementations we tested (DragonFlyBSD, FreeBSD, MirOS BSD, NetBSD, OpenBSD, and OS X) supports escape sequences, say "\n", in FORMAT:

# jot -w '%g\x41' 1
1\x41

enum is able to unescape "\x41" properly:

# enum -w '%g\x41' 1
1A

On a side note, "\x25" produces a literal "%"; it does not make a placeholder:

# enum -w '%g \x25g' 1
1 %g

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

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 should manually append a placeholder:

# enum -w test_%d 3
test_1
test_2
test_3

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 the ASCII character with code 48. We have no intention of duplicating this mix, at the moment.

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}.

In contrast to GNU seq, enum supports enumerating decreasing values:

# seq 3 1
# enum 3 1
3
2
1

GNU seq does not support escape sequences, say "\n", in FORMAT:

# seq -f '%g\x41' 1
1\x41

In contrast, some of the other seq implementations around do. These three behaviours can be observed (as of 2010-10-25):

seq of Plan 9, 9base, and GNU seq:

# seq -f '%g\x41' 3
1\x41
2\x41
3\x41

seq on FreeBSD and NetBSD:

# seq -f '%g\x41' 1
1A
2A
3A

seq on DragonFlyBSD:

# seq -f '%g\x41' 1
1A3
2A3
3A3

enum unescape "\x41" to "A" as well:

# enum -f '%g\x41' 3
1A
2A
3A

On a side note, "\x25" produces a literal "%"; it does not make a placeholder:

# enum -f '%g \x25g' 1
1 %g

By specifying -n as a parameter, you can make enum omit the trailing newline.