Hello, I finally back. =)

Is there any function or macro which can "round to the nearest whole
number"?
For example, I want to round from the first decimals as
   3.51 -> 4
   3.4445 -> 3

Thanks for your help.

(round 2.5)
=> 2

I would want it to return 3.

(Of course `better' is not really absolute, you can compensate for the
upward drift I think, but it makes things fiddly, especially for
people (like me) who are naive about floating point).

round

* (floor (+ 2.5 1/2))
=> 3
   0.0

  If you want that, you don't want rounding, but some sort of fraudulent
  scheme perpetrated by merchants and banks and other money institutions
  who want to keep your round-off change.  Less rebelliously, the sum of
  _rounded_ values should equal the rounded sum of the unrounded values,
  and if this does not hold, you have an _unmathematical_ operation.

  However, you may well define your "rounding" function thus:

(defun penny-theft (number)
  (multiple-value-bind (rounded rest)
      (truncate (+ number .5))
    (values rounded (- rest .5))))

 (round (+ 2.2 2.2 2.2 2.2 2.2))
   vs
 (reduce #'= (mapcar #'round '(2.2 2.2 2.2 2.2 2.2)))

|   Less rebelliously, the sum of
|   _rounded_ values should equal the rounded sum of the unrounded values,
|   and if this does not hold, you have an _unmathematical_ operation.

Unmathematical in what sense?

* (let ((x 2.3) (y 2.4))
    (list '= (+ (round x) (round y)) (round (+ x y))))

(= 4 5)

As a mathematician, I don't call some operations unmathematical if
they fail to commute.

Anyway, round as defined in CL has the very desirable property that if
(+ x y) happens to be an integer, *then* (+ (round x) (round y))
equals (round (+ x y)).  So whether the honest merchant rounds
the value owed before computing your change or computes the change and
then rounds the result, the answer is the same.

Actually, the "merchant" that this issue often has more of an effect on is
the government, when computing sales tax.  The total tax often differs
depending on whether it's computed on each item or the final total.

-
 -
  ---
     -
      -

| In article <pcoelzump3v....@thoth.home>,
| Harald Hanche-Olsen  <han...@math.ntnu.no> wrote:
| >Anyway, round as defined in CL has the very desirable property that if
| >(+ x y) happens to be an integer, *then* (+ (round x) (round y))
| >equals (round (+ x y)).  So whether the honest merchant rounds
| >the value owed before computing your change or computes the change and
| >then rounds the result, the answer is the same.
|
| But just make sure that you don't buy more than two things at once!

Actually, what I wrote isn't even true, as the example x=y=2.5 shows
all too clearly.

(unless (improves (quality (usenet-posts me)))
  (revert-to-lurking-mode))

Erik>   If you want that, you don't want rounding, but some sort of
Erik> fraudulent scheme perpetrated by merchants and banks and other
Erik> money institutions who want to keep your round-off change.  Less
Erik> rebelliously, the sum of _rounded_ values should equal the
Erik> rounded sum of the unrounded values, and if this does not hold,
Erik> you have an _unmathematical_ operation.

Um, "mathematics" isn't as stringent as you seem to be indicating
here.

It would be _nice_ if the sum of the rounded values should equal the
rounding of the sum of the unrounded values; that isn't necessarily
possible.

After all, suppose we have:
   (defvar values '(2.2 3.2 4.2 5.2))
and want to round to the nearest integer.

[4]> (apply #'+ values)

14.8

The reasonable rounding of that total would be to 15.

The _reasonable_ rounding of the individual values would get you
  (2 3 4 5)
whose sum is 14.

I can't think of a reasonable rounding rule that would round just
_one_ of those four values up so as to satisfy your expectation that:

I don't think that there _is_ a "mathematical operation" to correspond
to our-round.

Erik>   However, you may well define your "rounding" function
Erik> thus:

Erik> (defun penny-theft (number) (multiple-value-bind (rounded
Erik> rest) (truncate (+ number .5)) (values rounded (- rest
Erik> .5))))

Providing a somewhat more elaborate set of examples:

(defparameter *sample1* '(2.2 3.2 4.2 5.2 6.2 7.2 8.2 9.2 10.2))
(defparameter *sample2*
  (list (random 15.2)(random 15.2)(random 15.2)(random 15.2)(random 15.2)
        (random 15.2)(random 15.2)(random 15.2)(random 15.2)(random 15.2)))

(defun rounding-naggum-penny-theft (number)
  (multiple-value-bind
      (rounded rest)
      (truncate (+ number .5))
    (values rounded (- rest .5))))

(defun round-to-even (number)
  "Rounds to the nearest integer; breaks ties by rounding to a round integer."
  (multiple-value-bind
      (int-part fp-part)
      (truncate number)
    (let ((new-int (cond
                    ((> fp-part 0.5) (+ int-part 1))
                    ((< fp-part 0.5) int-part)
                    (t
                     (if (evenp int-part)
                         int-part
                       (+ int-part 1))))))
      (values new-int (- number new-int)))))

(format t "Round-then-add gives: ~D~%Add-then-round gives: ~D~%"
        (apply #'+ (mapcar #'round-to-even *sample1*))
        (round-to-even (apply #'+ *sample1*)))

(format t "Round-then-add gives: ~D~%Add-then-round gives: ~D~%"
        (apply #'+ (mapcar #'rounding-naggum-penny-theft *sample1*))
        (rounding-naggum-penny-theft (apply #'+ *sample1*)))

(format t "Round-then-add gives: ~D~%Add-then-round gives: ~D~%"
        (apply #'+ (mapcar #'round *sample1*))
        (round (apply #'+ *sample1*)))

(format t "Round-then-add gives: ~D~%Add-then-round gives: ~D~%"
        (apply #'+ (mapcar #'round-to-even *sample2*))
        (round-to-even (apply #'+ *sample2*)))

(format t "Round-then-add gives: ~D~%Add-then-round gives: ~D~%"
        (apply #'+ (mapcar #'rounding-naggum-penny-theft *sample2*))
        (rounding-naggum-penny-theft (apply #'+ *sample2*)))

(format t "Round-then-add gives: ~D~%Add-then-round gives: ~D~%"
        (apply #'+ (mapcar #'round *sample2*))
        (round (apply #'+ *sample2*)))

; Results:
; Round-then-add gives: 54
; Add-then-round gives: 56
; Round-then-add gives: 54
; Add-then-round gives: 56
; Round-then-add gives: 54
; Add-then-round gives: 56
; Round-then-add gives: 65
; Add-then-round gives: 64
; Round-then-add gives: 65
; Add-then-round gives: 64
; Round-then-add gives: 65
; Add-then-round gives: 64

    Andy> (round 2.5) => 2

    Andy> I would want it to return 3.

It's fair enough to say that someone rounding the price of a product
after doing tax calculations might prefer to round up if, at all
possible, so as to charge the customer as much as possible.

Robert

* Erik Naggum
| Less rebelliously, the sum of _rounded_ values should equal the
| rounded sum of the unrounded values, and if this does not hold, you
| have an _unmathematical_ operation.

What do you mean by "unmathematical"?  A function in mathematics, say f,
is usually defined as a mapping from some set S to some number field R
in a way as to assign every x from S to some f(x) from R.  Note that f
does not necessarily have to be _homomorphic_ (if S has no + operation
this is clear from the outset), i.e. in general f(x+y) /= f(x)+f(y)
holds.

  An exaggeration intended to be so blatantly exaggerated that it would
  at least seem somewhat humorous to at least one person beside myself.
  With a rounding function called "penny-theft" and words like "less
  rebelliously", I'm _amazed_ that not a single soul could lighten up.

| * Stefan Simbuerger
| | What do you mean by "unmathematical"?
|
|   An exaggeration intended to be so blatantly exaggerated that it would
|   at least seem somewhat humorous to at least one person beside myself.
|   With a rounding function called "penny-theft" and words like "less
|   rebelliously", I'm _amazed_ that not a single soul could lighten up.

Well, mathematicians of course have no sense of humour, since humour
cannot be expressed in Zermelo-Fraenkel set theory.  Not to mention
that humour (the good kind) is usually self-referential, and this
would tie us into some kind of Gödelian knot if we tried it.

Lispers thrive on self-reference of course, since lambda calculus has
no problems dealing with it.  So they're always full of fun.  Which is
why I lurk (most of the time) on this newsgroup, trying to figure out
what this humour thing is all about.

I'll bet it isn't all it's cracked up to be, though.

  Because it's a much simpler concept, even though both are essentially
  destructive in nature and it is always hard to agree on what should be
  destroyed because of the complexity of the concept of justice..  Those
  who object to "abusive" out of a gut feeling do not object to "humor",
  even though the latter is sometimes more destructive.  E.g., nobody
  has arrested that ridiculously pompous nincompoop Marcus G.  Daniels
  for any of his attempts at purely destrucdtive "humor", but if anyone
  is abusive towards the expectation of respect for _people_ in this
  forum, he's your best bet.  Light-heartedness is something other than
  humor, though.  And lightening up is the opposite of pompousness.