Topic: Range Function

[ribarm]

Code - Auto/Visual Lisp: [Select]

1. (defun range (s e i f)
2.   (if (or (and (> i 0) (< s e)) (and (< i 0) (> s e)))
3.     (progn (f s) (range (+ i s) e i f))
4.   )
5. )
6.  
7. (defun test (s e i / tot)
8.   (setq tot 0)
9.   (range s e i (lambda (a) (setq tot (+ tot a))))
10.   tot
11. )
12.  
13. (test 0 10 1) >> 45
14. (test 0 10 1) >> 45
15.  

[ElpanovEvgeniy]

Code - Auto/Visual Lisp: [Select]

1. (defun test (s e i a / tot)
2.   (range s e i (lambda (a) (setq tot (+ tot a))))
3.   tot
4. )
5.  
6. (test 0 10 1 0) >> 45
7. (test 0 10 1 0) >> 45
8.  

 

Code - Auto/Visual Lisp: [Select]

1. (test 0 10 1 0) ; >> 45
2. (test 0 10 1 55) ; >> 100

[ribarm]

So what, little testings where I was wrong...

Code - Auto/Visual Lisp: [Select]

1. (defun range (s e i f)
2.   (if (or (and (> i 0) (< s e)) (and (< i 0) (> s e)))
3.     (progn (f s) (range (+ i s) e i f))
4.   )
5. )
6.  
7. (defun test (s e i tot)
8.   (range s e i (lambda (a) (setq tot (+ tot a))))
9.   tot
10. )
11.  
12. (test 0 10 1 0) >> 45
13. (test 0 10 1 0) >> 45
14. (test 0 10 1 55) >> 100
15.  

[ElpanovEvgeniy]

So what, little testings where I was wrong...

it was my bug...

[ymg]

Code - Auto/Visual Lisp: [Select]

1. ;;  By Cab      (iterative)                                                   ;
2. ;;                                                                            ;
3.  
4. (defun in_rangec (start end step / value)
5.   (setq value (list start))
6.   (repeat (fix (/ (- end start) step))
7.      (setq value (cons (setq start (+ step start)) value))
8.   )
9.   (reverse (if (= (car value) end) (cdr value) value))
10. )
11. ;; By ElpanovEvgeniy       (recursive)                                        ;
12. (defun in_range (s e i)
13.   (if (or (and (> i 0) (< s e)) (and (< i 0) (> s e)))
14.     (cons s (in_range (+ i s) e i))
15.   )
16. )
17.  
18.  
19. (defun c:test ()
20.   (setq ti (car (_vl-times)))
21.   (repeat 5000
22.      (setq tot 0)
23.      (foreach i (in_range 0 10 1)
24.         (setq tot (+ tot i))
25.      )
26.   )
27.   (princ (strcat "\nRecursive in_range(): " (rtos (/ (- (car (_VL-TIMES)) ti) 1000.) 2 4) " secs"))
28.   (princ)
29. )
30.  
31. (defun c:test1 ()
32.   (setq ti (car (_vl-times)))
33.   (repeat 5000
34.      (setq tot 0)
35.      (foreach i (in_rangec 0 10 1)
36.         (setq tot (+ tot i))
37.      )
38.   )
39.   (princ (strcat "\nIterative in_range(): " (rtos (/ (- (car (_VL-TIMES)) ti) 1000.) 2 4) " secs"))
40.   (princ)
41. )
42.  
43. (defun c:test2 ()
44.   (setq ti (car (_vl-times)))
45.   (repeat 5000
46.      (setq tot 0 i 0)
47.      (repeat 9
48.         (setq tot (+ tot (setq i (1+ i))))
49.      )
50.   )
51.   (princ (strcat "\nTraditionnal Index: " (rtos (/ (- (car (_VL-TIMES)) ti) 1000.) 2 4) " secs"))
52.   (princ)
53. )
54.  

_$ (c:test)
Recursive in_range(): 0.109 secs

_$ (c:test1)
Iterative inrange(): 0.109 secs

_$ (c:test2)
Traditionnal Index: 0.047 secs
_$

[ribarm]

It should be almost like (c:test2)...

Code - Auto/Visual Lisp: [Select]

1. (defun c:test3 ()
2.  (setq ti (car (_vl-times)))
3.  (setq n (- (length (in_range 0 10 1)) 1)) ;;; or (setq n (- (length (in_rangec 0 10 1)) 1))
4.  (repeat 5000
5.     (setq tot 0 i 0)
6.     (repeat n
7.        (setq tot (+ tot (setq i (1+ i))))
8.     )
9.  )
10.  (princ (strcat "\nTraditionnal combined Index: " (rtos (/ (- (car (_VL-TIMES)) ti) 1000.) 2 4) " secs"))
11.  (princ)
12. )
13.  
14. (defun c:test4 ()
15.  (setq ti (car (_vl-times)))
16.  (setq l (in_range 0 10 1)) ;; or (setq l (in_rangec 0 10 1))
17.  (repeat 5000
18.     (setq tot 0)
19.     (foreach i l
20.        (setq tot (+ tot i))
21.     )
22.  )
23.  (princ (strcat "\nForeach in_range(): " (rtos (/ (- (car (_VL-TIMES)) ti) 1000.) 2 4) " secs"))
24.  (princ)
25. )
26.  

[ymg]

It should be almost like (c:test2)...

Marko,

You are right test4 is more like the real situation and comes out at
exactly the same time as the traditional index.

_$ (c:test4)
Foreach in_range(): 0.047 secs

[roy_043]

@ ymg & ribarm
Benchmarking is not a 'real situation'. If you are trying to benchmark the range functions you should keep it inside the (repeat 5000 ...) loop.

[roy_043]

Code: [Select]

Benchmarking .......... elapsed milliseconds / relative timing <5000 iterations>

  (KGA_LIST_INDEXSEQMAKESTARTEND 0 100) ..... 125 / 4.62 <fastest>
  (CAB_IN_RANGE 0 100 1) .................... 235 / 2.46
  (EE_IN_RANGE 0 100 1) ..................... 578 / 1.00 <slowest>
My function (KGA_List_IndexSeqMakeStartEnd) is not a true range function, but I think the numbers confirm the effectiveness of the speed improvement method for large ranges (0-100).
For the (CAB_in_range) and (EE_in_range) functions see reply #34 by ymg.

[ymg]

@ ymg & ribarm
Benchmarking is not a 'real situation'. If you are trying to benchmark the range functions you should keep it inside the (repeat 5000 ...) loop.

roy_043,

What we are trying to assess is How it compares to a traditionnal incrementing of a separate index
in a loop.

That means that Marko's logic is right for the case at hand.

In other word using this method or the traditional one is essentially equivalent time-wise.

And yes we could use your code and maybe gain a little.

ymg

To be complete:

Code: [Select]

;; By roy_043                                                                 ;
(defun in_ranger (start end / len ret step)
  (setq step (if (< start end) -1 1))
  (repeat (rem (setq len (fix (abs (- end start)))) 8)
    (setq ret (cons (setq end (+ end step)) ret))
  )
  (repeat (/ len 8)
    (setq ret
      (vl-list*
        (+ end (* 8 step))
        (+ end (* 7 step))
        (+ end (* 6 step))
        (+ end (* 5 step))
        (+ end (* 4 step))
        (+ end (* 3 step))
        (+ end (* 2 step))
        (+ end step)
        ret
      )
    )
    (setq end (+ end (* 8 step)))
  )
  ret
)

(defun c:testr ()
 (setq ti (car (_vl-times)))
 (setq l (in_ranger 0 10)) ;; or (setq l (in_rangec 0 10 1))
 (repeat 5000
    (setq tot 0)
    (foreach i l
       (setq tot (+ tot i))
    )
 )
 (princ (strcat "\nForeach in_ranger(): " (rtos (/ (- (car (_VL-TIMES)) ti) 1000.) 2 4) " secs"))
 (princ)
)


(c:testr)
Foreach in_ranger(): 0.0470 secs

[Lee Mac]

@roy: Just curious, why 8? Why not more (or less)?

[roy_043]

@roy: Just curious, why 8? Why not more (or less)?

From my test file:

Code: [Select]

;;; 20111115
;;; Conclusions:
;;; The (repeat) loop with (setq) is very time consuming.
;;; Using serial (cons) is usually slower than using (vl-list*).
;;; Using (append) is of course bad for speed.
;;; (KGA_LIST_INDEXSEQMAKELENGTH_08) has an acceptable balance between speed gain and program length.
 
; Benchmarking .......... elapsed milliseconds / relative timing <1000 iterations>

  ; (KGA_LIST_INDEXSEQMAKELENGTH_32 1000) ...... 125 / 2.88 <fastest>
  ; (KGA_LIST_INDEXSEQMAKELENGTH_16 1000) ...... 140 / 2.57
  ; (KGA_LIST_INDEXSEQMAKELENGTH_08 1000) ...... 172 / 2.09
  ; (KGA_LIST_INDEXSEQMAKELENGTH_04 1000) ...... 234 / 1.54
  ; (KGA_LIST_INDEXSEQMAKELENGTH_01 1000) ...... 360 / 1.00 <slowest>

[Lee Mac]

Very thorough roy 

[roy_043]

Very thorough roy 

:kewl: