Topic: Well tested common functions library - should we have it?

[roy_043]

2. Consistent naming scheme? You now have predicate functions with names that do not end in '-p'.

Which?

consp
some
every

[divtiply]

They are standard CL names. As null, for example.

[MP]

Have seen so many try-outs -- ALL have failed.

Pretty much this -- a six member committee with 12 legs -- will try to walk in as many directions -- good luck.

[roy_043]

They are standard CL names. As null, for example.

1.
Why look at CL?

[roy_043]

BTW: My (roy_some_2) has a problem:

Code: [Select]

(defun MyFunc (a) (if (numberp a) (1+ a)))
(roy_some_2 'MyFunc '("a" "b" "c" "d" 0)) => 1
(roy_some_2 'MyFunc '("a" "b" "c" 0)) => T
New version:

Code - Auto/Visual Lisp: [Select]

1. (defun roy_some_2_Revised (pred lst / res)
2.   (setq pred (eval pred))
3.   (while
4.     (and
5.       (cadddr lst)
6.       (not
7.         (setq res
8.           (cond
9.             ((pred (car lst)))
10.             ((pred (cadr lst)))
11.             ((pred (caddr lst)))
12.             ((pred (cadddr lst)))
13.           )
14.         )
15.       )
16.     )
17.     (setq lst (cddddr lst))
18.   )
19.   (if (not res)
20.     (while
21.       (and
22.         (car lst)
23.         (not (setq res (pred (car lst))))
24.       )
25.       (setq lst (cdr lst))
26.     )
27.   )
28.   res
29. )

[snownut2]

Roy,

Why "cad....r" and not "nth #"  much easier to read a number then how many "d's" to use. 

Bruce

[divtiply]

Why "cad....r" and not "nth #"

"cad...r" functions are faster than "nth n" equivalents.

[roy_043]

Roy,

Why "cad....r" and not "nth #"  much easier to read a number then how many "d's" to use. 

Bruce

Apart from the issue of speed there also this:
On line 5 of (roy_some_2_revised) I have:

Code: [Select]

(cadddr lst)Because lst can be or become nil (nth) cannot be used here:

Code: [Select]

(nth 3 nil) => Error
(cadddr nil) => nil

[snownut2]

Roy,

Thanks for the explanation, I did not know about the nil/error difference.

Bruce

[Jeremy]

I share some of DIVTIPLY's concerns. There are a great many functions on this board that have been optimized and benchmarked but can be impossible to find unless you know they exist. It would be nice if there could be a place to drop the most optimized version of various functions in one spot where you can see them all categorized. This would of course need updating as new people submit better algorithms. We could suggest that people use these functions in submitted code so that one is not constantly bothered with making sure every subfunction to a given function is included. A lot of repetitious space is being used over and over again.

Setting some rules for function naming is important because Autolisp is kind of a mess in that regard. Predicate functions are indeed not consistent and I have ended all of mine with a question mark rather than -p. I think "number?" is more quickly recognized as an inquiry than "numberp" is. Perhaps I am excessive but I also wrote replacements for the operators and booleans that have no "p" at all. So I have "less?" as well as "<" and "wcmatch?" instead of "wcmatch". Rather than "First","Second","Third" I would gravitate towards "1st","2nd" and "3rd" as they are shorter and I believe the digits are more rapidly comprehended than the words.

[roy_043]

FWIW: Another look at the (some) function.

Code: [Select]

(vl-some 'atom nil)              => nil
(divtiply_some 'atom nil)        => T
(roy_some_1 'atom nil)           => T
(roy_some_2_Revised 'atom nil)   => nil
(roy_some_1_Revised_2 'atom nil) => nil
(roy_some_2_Revised_2 'atom nil) => nil

(vl-some 'atom '(nil))              => T
(divtiply_some 'atom '(nil))        => T
(roy_some_1 'atom '(nil))           => T
(roy_some_2_Revised 'atom '(nil))   => nil
(roy_some_1_Revised_2 'atom '(nil)) => T
(roy_some_2_Revised_2 'atom '(nil)) => T

(vl-some 'numberp '(nil nil 0 . 0))              => T
(divtiply_some 'numberp '(nil nil 0 . 0))        => T
(roy_some_1 'numberp '(nil nil 0 . 0))           => T
(roy_some_2_Revised 'numberp '(nil nil 0 . 0))   => Error
(roy_some_1_Revised_2 'numberp '(nil nil 0 . 0)) => T
(roy_some_2_Revised_2 'numberp '(nil nil 0 . 0)) => T

(vl-some 'numberp '(nil nil . 0))              => nil
(divtiply_some 'numberp '(nil nil . 0))        => Error
(roy_some_1 'numberp '(nil nil . 0))           => Error
(roy_some_2_Revised 'numberp '(nil nil . 0))   => Error
(roy_some_1_Revised_2 'numberp '(nil nil . 0)) => nil
(roy_some_2_Revised_2 'numberp '(nil nil . 0)) => nil

Code - Auto/Visual Lisp: [Select]

1. (defun roy_some_1_Revised_2 (pred lst / res)
2.   (setq pred (eval pred))
3.   (while
4.     (and
5.       (vl-consp lst)
6.       (not (setq res (pred (car lst))))
7.     )
8.     (setq lst (cdr lst))
9.   )
10.   res
11. )
12.  
13. (defun roy_some_2_Revised_2 (pred lst / res)
14.   (setq pred (eval pred))
15.   (while
16.     (and
17.       (vl-consp lst)
18.       (vl-consp (cdr lst))
19.       (vl-consp (cddr lst))
20.       (vl-consp (cdddr lst))
21.       (not
22.         (setq res
23.           (cond
24.             ((pred (car lst)))
25.             ((pred (cadr lst)))
26.             ((pred (caddr lst)))
27.             ((pred (cadddr lst)))
28.           )
29.         )
30.       )
31.     )
32.     (setq lst (cddddr lst))
33.   )
34.   (if (not res)
35.     (while
36.       (and
37.         (vl-consp lst)
38.         (not (setq res (pred (car lst))))
39.       )
40.       (setq lst (cdr lst))
41.     )
42.   )
43.   res
44. )

[ymg]

Here some revised ceil and floor function.

These you may attribute to me although probably was done before.

Code - Auto/Visual Lisp: [Select]

1. (defun floor (x) (if (minusp (rem x 1)) (- (fix x) 1) (fix x)))
2. (defun ceil  (x) (if (> (rem x 1) 0) (+ (fix x) 1) (fix x)))
3.  

@divtiply
As an aside, it would certainly have been appreciated if you had let me know
in the Poisson Disk Sampling thread about the problem.

ymg

[roy_043]

Since the OP is a BricsCAD user this may be of interest:

BricsCAD uses OpenLisp as the basis for its Lisp-engine:
http://www.eligis.com/
OpenLisp is an ISLISP implementation:
http://islisp.info/

To be compatible with AutoLisp some functionality from the underlying Lisp-engine is blocked in BricsCAD. Which can be a frustrating idea if you goal is to extend the Lisp-library.

Note: there is also a different OpenLISP:
http://www.openlisp.org/

Edit: Typo.

[snownut2]

Roy,

A little off subject, but do you know if OpenLisp from your last post supports DCL use.

Bruce

[roy_043]

do you know if OpenLisp from your last post supports DCL use.

DCL is unique to AutoCAD and some other .dwg software. So the answer is: No.