Re: number-sequence

[Luc Teirlinck]

Below is the latest revised version of number-sequence, taking the
suggestions of Kim and Juri into account.  Even though Kim's changes
improved number-sequence's handling of floating point arguments, the
function does not handle floats ideally, but I do not believe that
anything can be done about that.  The function was mainly designed
for, and, I believe, is mainly useful, for integer arguments.  I
pointed this out in the doc string (this is an additional change from
the previous version).

Juri Linkov wrote:

   BTW, it couldn't hurt to add examples to the docstring:

The doc string is already getting long and there already are examples
in the Elisp manual which I will update.  After updating, depending on
the actual examples in the updated version, I might add a sentence:

For examples, see Info node `(elisp)Building Lists'.

to the very end of the doc string, if this would appear to be useful.

I will wait a while (at least till Sunday) to see whether there are
any objections or further suggestions, after which I will commit,
update the Elisp manual and the NEWS.

===File ~/new-number-sequence.el============================
(defun number-sequence (from &optional to inc)
  "Return a sequence of numbers from FROM to TO (both inclusive) as a list.
INC is the increment used between numbers in the sequence.
So, the Nth element of the list is (+ FROM (* N INC)) where N counts from
zero.
TO is only included if there is an N for which TO = FROM + N * INC.  
If INC is nil, it defaults to 1 (one) if TO is larger than FROM,
or to -1 if TO is less than FROM.
If TO is nil or numerically equal to FROM, return (FROM).
If INC is positive and TO is less than FROM, or INC is negative
and TO is larger than FROM, return nil.
If INC is zero and TO is neither nil nor numerically equal to
FROM, signal an error.

This function was primarily designed for integer arguments.
Nevertheless, FROM, TO and INC can be integer or float.  However,
floating point arithmetic is inexact.  For instance, depending on
the machine, it may quite well happen that
\(number-sequence 0.4 0.6 0.2) returns the one element list (0.4),
whereas \(number-sequence 0.4 0.8 0.2) returns a list with three
elements.  Thus, if some of the arguments are floats and one
wants to make sure that TO is included, one may have to
explicitly write TO as \(+ FROM \(* N INC)) or use a variable
whose value was computed with this exact expression."
  (if (or (not to) (= from to))
      (list from)
    (or inc (setq inc (if (< from to) 1 -1)))    
    (when (zerop inc) (error "The increment can not be zero"))
    (let (seq (n 0) (next from))
      (if (> inc 0)
          (while (<= next to)
            (setq seq (cons next seq)
                  n (1+ n)
                  next (+ from (* n inc))))
        (while (>= next to)
          (setq seq (cons next seq)
                n (1+ n)
                next (+ from (* n inc)))))
      (nreverse seq))))
============================================================