Topic: problem with rem function

[ribarm]

Code: [Select]

    (if (or (= (type n1) 'real) (= (type n2) 'real))
      0.0
      0
    )


this should be changed to n1

This is not so important - original (rem) function returns real here - although it's wrong :

Command: (rem 1 2.0)
1.0
Command: (rem 1 0.5)
0.0

[ribarm]

Actually I was wrong... This was correct :

Code: [Select]

Command: (rem 1 2)
1
Command: (rem 1 2.0)
1.0
Command: (rem 1 0.5)
0.0

I just overprogrammed it... So it's simply :

Code - Auto/Visual Lisp: [Select]

1. (defun rem ( n1 n2 )
2.   (if (or (= (type n1) 'real) (= (type n2) 'real))
3.     (if (minusp n1)
4.       (- (* (- (/ (float (abs n1)) (float (abs n2))) (fix (/ (float (abs n1)) (float (- (abs n2) 1e-15))))) (+ (abs n2) 1e-15)))
5.       (* (- (/ (float n1) (float (abs n2))) (fix (/ (float n1) (float (- (abs n2) 1e-15))))) (+ (abs n2) 1e-15))
6.     )
7.     (if (minusp n1)
8.       (fix (- (+ (* (- (/ (float n1) (float (abs n2))) (fix (/ (float n1) (float (- (abs n2) 1e-15))))) (+ (abs n2) 1e-15)) 1e-8)))
9.       (fix (+ (* (- (/ (float n1) (float (abs n2))) (fix (/ (float n1) (float (- (abs n2) 1e-15))))) (+ (abs n2) 1e-15)) 1e-8))
10.     )
11.   )
12. )
13.  

Sorry, we all make mistakes sometimes, but built-in function was also wrong... At least I think I fixed it now for sure...
Regards, M.R.

[efernal]

since problem is known, fixed it:

(rem (* 10 0.1)(* 10 0.1))
(rem (* 10 0.2)(* 10 0.1))
(rem (* 10 0.3)(* 10 0.1))
(rem (* 10 0.4)(* 10 0.1))
(rem (* 10 0.5)(* 10 0.1))
(rem (* 10 0.6)(* 10 0.1))
(rem (* 10 0.7)(* 10 0.1))
(rem (* 10 0.(* 10 0.1))
(rem (* 10 0.9)(* 10 0.1))
(rem (* 10 1.0)(* 10 0.1))
(rem (* 10 1.1)(* 10 0.1))
(rem (* 10 1.2)(* 10 0.1))
(rem (* 10 1.3)(* 10 0.1))
(rem (* 10 1.4)(* 10 0.1))
(rem (* 10 1.5)(* 10 0.1))

[efernal]

Command:
Command: (rem (* 10 0.1)(* 10 0.1))
0.0

Command: (rem (* 10 0.2)(* 10 0.1))
0.0

Command: (rem (* 10 0.3)(* 10 0.1))
0.0

Command: (rem (* 10 0.4)(* 10 0.1))
0.0

Command: (rem (* 10 0.5)(* 10 0.1))
0.0

Command: (rem (* 10 0.6)(* 10 0.1))
0.0

Command: (rem (* 10 0.7)(* 10 0.1))
0.0

Command: (rem (* 10 0.(* 10 0.1))
0.0

Command: (rem (* 10 0.9)(* 10 0.1))
0.0

Command: (rem (* 10 1.0)(* 10 0.1))
0.0

Command: (rem (* 10 1.1)(* 10 0.1))
0.0

Command: (rem (* 10 1.2)(* 10 0.1))
0.0

Command: (rem (* 10 1.3)(* 10 0.1))
0.0

Command: (rem (* 10 1.4)(* 10 0.1))
0.0

Command: (rem (* 10 1.5)(* 10 0.1))
0.0

[mac0312]

Thanks all！ 

[mac0312]

Since rem is typically used to test the even divisibility of a number by a given divisor, you can easily account for the rounding errors introduced by the limited precision of the double-precision floating-point format by simply testing the result with some tolerance, e.g.:

Code - Auto/Visual Lisp: [Select]

1. (defun divp ( x d )
2.     ((lambda ( r ) (or (equal 0.0 r [color=red]1e-8[/color]) (equal d r 1e-8))) (rem x d))
3. )

Code - Auto/Visual Lisp: [Select]

1. _$ (divp 13.1 0.1)
2. T

(divp 12.4 0.1)→(rem x d)
Sometimes 1.0e-006, sometimes 1.0e-008

[Lee Mac]

I think 1e-8 is more than sufficient -

Code - Auto/Visual Lisp: [Select]

1. _$ (rtos (rem 12.4 0.1) 2 17)
2. "0.09999999999999966"

[ribarm]

I think 1e-8 is more than sufficient -

Code - Auto/Visual Lisp: [Select]

1. _$ (rtos (rem 12.4 0.1) 2 17)
2. "0.09999999999999966"

Lee are you saying (rem) built-in function is working well... I think this was bug... (rem 12.4 0.1) should be 0.0 and not 0.1... (/ 12.4 0.1) = 124 without reminder - reminder is 0.0

[Lee Mac]

I think 1e-8 is more than sufficient -

Code - Auto/Visual Lisp: [Select]

1. _$ (rtos (rem 12.4 0.1) 2 17)
2. "0.09999999999999966"

Lee are you saying (rem) built-in function is working well... I think this was bug... (rem 12.4 0.1) should be 0.0 and not 0.1... (/ 12.4 0.1) = 124 without reminder - reminder is 0.0

I'm saying that issues such as this are inevitable when working with doubles due to the inability to represent certain Real numbers with finite memory, and one has to remember that the error introduced at the nth decimal place can be both positive & negative; in this case, since we are working with modular arithmetic, the error will be either 0+1e-16 or m-1e-16 where m is the modulus.

[ribarm]

But with my function, there is no such issue... I've reprogrammed (rem) function to be correct... And I placed it at first place in my acaddoc.lsp before all other things and I've tested it with my acaddoc.lsp, this returned 0.0 which is correct :

Code: [Select]

(defun c:remtest nil
  (princ (rem 13.3 0.1))
  (princ)
)

My function, if you didn't noticed is here :
http://www.theswamp.org/index.php?topic=53061.msg597469#msg597469

M.R.

[MP]

I'm probably missing something but why would it need to be more ambitious than:

Code: [Select]

(defun _rem ( n d / r )
    (cond
        ((equal 0 (setq r (rem n d)) 1e-6) 0)
        ((apply 'equal (mapcar 'abs (list d r 1e-6))) 0)
        (r)
    )
)
?

[ribarm]

Yes, you are missing something :
My (rem n1 n2) is designed to overwrite buit-in (rem) function, and your if you change name (_rem) to (rem) it will act recursively calling function you just defined and not built-in (rem)... I am afraid it has to be my way if you want to overwrite original (rem) definition...

[MP]

I didn’t intend to overwrite the built in function thus my naming was deliberate. In over 30 years of LISP programming I don’t recall ever having such need and remain of the opinion it should be avoided [unless replicating Joshua Overkamp’s efforts of late - highly unlikely for me]. Mileages vary of course.

[ribarm]

...remain of the opinion it should be avoided [unless replicating Joshua Overkamp’s efforts of late - highly unlikely for me]...

Why would you keep original (rem) if you know it's buggy? I would say if you can mention where is this errornous odd behaviour of original (rem) used in correct and succesful manner, then I'll appreciate your opinion, otherwise I and perhaps everyone else would suggest (strongly) that you should overwrite buggy (rem)... As for efficency behaviour it's I suppose just slightly slower than original as its not built-in optimized Alisp Function like others are...

[VovKa]

buggy

(rem_ribarm 1 0.0000000000001)