Author Topic: Well tested common functions library - should we have it? (Read 16490 times)

divtiply · « **on:** December 06, 2013, 08:53:31 AM »

Whe are reinventing the wheel, again and again. It's not bad - we are learning.
The bad is that some of common functions are implemented wrongly or not time effective.
For example, ymg's ceil/floor functions [http://www.theswamp.org/index.php?topic=45379.msg505421#msg505421]:

Code - Auto/Visual Lisp: [Select]

;; Ceiling function, Returns the smallest integer not less than x.            ;
(defun ceil (x) (if (minusp x)(fix x)(1+ (fix x))))
;; Floor function, Returns the largest integer not greater than x.            ;
(defun floor (x) (if (minusp x)(1- (fix x))(fix x)))

are little bit wrong, because:

Code - Auto/Visual Lisp: [Select]

(ceil 1) => 2
(floor -1) => -2

Correct implementation is:

Code - Auto/Visual Lisp: [Select]

(defun floor (num)
  (if (zerop (- num (setq num (fix num))))
    num
    (if (minusp num) (1- num) num)))
 
(defun ceiling (num)
  (if (zerop (- num (setq num (fix num))))
    num
    (if (minusp num) num (1+ num))))

So, should we make a library with a well tested, speed effective functions?

Lee Mac · « **Reply #1 on:** December 06, 2013, 09:06:04 AM »

Quote from: divtiply on December 06, 2013, 08:53:31 AM

So, should we make a library with a well tested, speed effective functions?

http://autocad.xarch.at/stdlib/html/

divtiply · « **Reply #2 on:** December 06, 2013, 09:09:56 AM »

Quote from: Lee Mac on December 06, 2013, 09:06:04 AM

http://autocad.xarch.at/stdlib/html/

Same as ymg's implementation error in std-floor/std-ceiling.
So it is not well tested

))

LE3 · « **Reply #3 on:** December 06, 2013, 09:21:21 AM »

An ex-lisper comment:

In all my past years spent (20+-) in the autolisp/vlisp world --- the only way or form I have seen to adopt a function as standard it is when these are added into the autolisp core. Anything out it will be way too difficult - will only be part of anyone's personal functions arsenal. Have seen so many try-outs -- ALL have failed.

Let see if this time not.

LE!

divtiply · « **Reply #4 on:** December 06, 2013, 09:25:22 AM »

I'll give you a bit, tell me should I continue?

Code - Auto/Visual Lisp: [Select]

(if vl-consp
  (setq consp vl-consp)
  (defun consp (obj)
    (not (atom obj))))
 
(defun dotted-pair-p (obj)
  (and (consp obj) (not (listp (cdr obj)))))
 
(if vl-list-length
  (defun dotted-list-p (obj)
    (and (consp obj)
         (not (vl-list-length obj))))
  (defun dotted-list-p (obj)
    (and (consp obj)
         (dotted-pair-p (last-pair obj)))))
 
(defun association-list-p (obj)
  (and (consp obj)
       (every 'consp obj)))
 
(setq first   (cond (vle-nth0)(car))
      second  (cond (vle-nth1)(cadr))
      third   (cond (vle-nth2)(caddr))
      fourth  (cond (vle-nth3)(cadddr))
      fifth   (cond (vle-nth4)((lambda (list) (car (cddddr list)))))
      sixth   (cond (vle-nth5)((lambda (list) (cadr (cddddr list)))))
      seventh (cond (vle-nth6)((lambda (list) (caddr (cddddr list)))))
      eighth  (cond (vle-nth7)((lambda (list) (cadddr (cddddr list)))))
      ninth   (cond (vle-nth8)((lambda (list) (car (cddddr (cddddr list))))))
      tenth   (cond (vle-nth9)((lambda (list) (cadr (cddddr (cddddr list))))))
      rest    cdr)
 
(if vle-sublist
  (defun nthcdr (n lst)
    (vle-sublist lst n 0))
  (defun nthcdr (n lst)
    (nth n (list nil)) ; parameter validation
    (while (and lst (not (zerop n)))
      (setq n (1- n)
            lst (cdr lst)))
    lst))
 
(if vle-sublist
  (defun firstn (n lst)
    (vle-sublist lst 0 n))
  (defun firstn (n lst / out)
    (nth n (list nil)) ; parameter validation
    (while (and lst (not (zerop n)))
      (setq n (1- n)
            out (cons (car lst) out)
            lst (cdr lst)))
    (reverse out)))
 
(if vle-sublist
  (defun lastn (n lst)
    (vle-sublist lst (- (length lst) n) 0))
  (defun lastn (n lst / out)
    (nth n (list nil)) ; parameter validation
    (setq lst (reverse lst))
    (while (and lst (not (zerop n)))
      (setq n (1- n)
            out (cons (car lst) out)
            lst (cdr lst)))
    out))
 
(defun last-pair (lst)
  (while (consp (cdr lst))
    (setq lst (cdr lst)))
  lst)
 
(if vle-remove-last
  (setq butlast vle-remove-last)
  (defun butlast (lst)
    (reverse (cdr (reverse lst)))))
 
(if vle-sublist
  (defun butlastn (n lst)
    (vle-sublist lst 0 (- (length lst) n)))
  (defun butlastn (n lst)
    (reverse (nthcdr n (reverse lst)))))
 
(defun ldiff (lst sublst / out)
  (while (and lst (not (eq lst sublst)))
    (setq out (cons (car lst) out)
          lst (cdr lst)))
  (reverse out))
 
(if vle-sublist
  (setq sublist vle-sublist)
  (defun sublist (lst start len)
    (firstn len (nthcdr start lst))))
 
(if vle-sublist
  (defun split-at (n lst)
    (cons (vle-sublist lst 0 n) (vle-sublist lst n 0)))
  (defun split-at (n lst / out)
    (nth n (list nil)) ; parameter validation
    (while (and lst (not (zerop n)))
      (setq n (1- n)
            out (cons (car lst) out)
            lst (cdr lst)))
    (cons (reverse out) lst)))
 
(defun split-at-first (item lst / out)
  (while (and lst (not (equal item (car lst))))
    (setq out (cons (car lst) out)
          lst (cdr lst)))
  (cons (reverse out) lst))
 
(defun split-at-last (item lst / out1 out2)
  (setq out1 (reverse lst))
  (while (and out1 (not (equal item (car out1))))
    (setq out2 (cons (car out1) out2)
          out1 (cdr out1)))
  (if out1
    (cons (reverse (cdr out1)) (cons (car out1) out2))
    (list lst)))
 
(defun split-if (pred lst / out)
  (while (and lst (not (apply pred (list (car lst)))))
    (setq out (cons (car lst) out)
          lst (cdr lst)))
  (cons (reverse out) lst))
 
(defun split-if-not (pred lst / out)
  (while (and lst (apply pred (list (car lst))))
    (setq out (cons (car lst) out)
          lst (cdr lst)))
  (cons (reverse out) lst))
 
(defun partition (pred lst / out1 out2)
  (foreach x lst
    (if (apply pred (list x))
      (setq out1 (cons x out1))
      (setq out2 (cons x out2))))
  (cons (reverse out1) (reverse out2)))
 
(if vl-list-length
  (setq list-length vl-list-length)
  (defun list-length (lst / len)
    (setq len 0)
    (while (and lst (listp (setq lst (cdr lst))))
      (setq len (1+ len)))
    (if (null lst) len)))
 
(defun revappend (lst obj)
  (while lst
    (setq obj (cons (car lst) obj)
          lst (cdr lst)))
  obj)
 
(defun unfold (p f g seed / lst)
  (while (not (apply p (list seed)))
    (setq lst (cons (apply f (list seed)) lst)
          seed (apply g (list seed))))
  (reverse lst))
 
(defun fold (fn init lst)
  (foreach x lst
    (setq init (apply fn (list x init))))
  init)
 
(defun reduce (func lst)
  (fold func (car lst) (cdr lst)))
 
(if vl-every
  (setq every vl-every)
  (defun every (pred lst / res)
    (while (and (setq res (apply pred (list (car lst))))
                (setq lst (cdr lst))))
    res))
 
(if vl-some
  (setq some vl-some)
  (defun some (pred lst / res)
    (while (and (setq res (not (apply pred (list (car lst)))))
                (setq lst (cdr lst))))
    (not res)))
 
(if vl-member-if
  (setq member-if vl-member-if)
  (defun member-if (pred lst)
    (while (and lst (not (apply pred (list (car lst)))))
      (setq lst (cdr lst)))))
 
(if vl-member-if-not
  (setq member-if-not vl-member-if-not)
  (defun member-if-not (pred lst) ; aka drop-while
    (while (and lst (apply pred (list (car lst))))
      (setq lst (cdr lst)))))
 
(if vl-position
  (setq position vl-position)
  (defun position (item lst / n)
    (setq n 0)
    (while (and lst (not (equal item (car lst))))
      (setq n (1+ n)
            lst (cdr lst)))
    (if lst n)))
 
(defun position-if (pred lst / n)
  (setq n 0)
  (while (and lst (not (apply pred (list (car lst)))))
    (setq n (1+ n)
          lst (cdr lst)))
  (if lst n))
 
(defun position-if-not (pred lst / n)
  (setq n 0)
  (while (and lst (apply pred (list (car lst))))
    (setq n (1+ n)
          lst (cdr lst)))
  (if lst n))
 
(defun count (item lst / cnt)
  (setq cnt 0)
  (foreach x lst
    (if (equal item x)
      (setq cnt (1+ cnt))))
  cnt)
 
(defun count-if (pred lst / cnt)
  (setq cnt 0)
  (foreach x lst
    (if (apply pred (list x))
      (setq cnt (1+ cnt))))
  cnt)
 
(defun count-if-not (pred lst / cnt)
  (setq cnt 0)
  (foreach x lst
    (or (apply pred (list x))
        (setq cnt (1+ cnt))))
  cnt)
 
(defun subst-if (new pred lst)
  (mapcar (function (lambda (x) (if (apply pred (list x)) new x)))
          lst))
 
(defun subst-if-not (new pred lst)
  (mapcar (function (lambda (x) (if (apply pred (list x)) x new)))
          lst))
 
(if vle-subst-nth
  (defun subst-nth (new n lst) 
    (vle-subst-nth lst n new))
  (defun subst-nth (new n lst)
    (setq lst (split-at n lst))
    (if (cdr lst)
      (append (car lst) (cons new (cddr lst)))
      (car lst))))
 
(if vle-subst-nth
  (defun subst-first (new old lst)
    (setq n (position old lst))
    (if n
      (vle-subst-nth lst n new)
      lst))
  (defun subst-first (new old lst)
    (setq lst (split-at-first old lst))
    (if (cdr lst)
      (append (car lst) (cons new (cddr lst)))
      (car lst))))
 
(defun subst-last (new old lst)
  (setq lst (split-at-last old lst))
      (if (cdr lst)
        (append (car lst) (cons new (cddr lst)))
        (car lst)))
 
(if vl-remove
  (setq remove vl-remove)
  (defun remove (item lst)
    (apply 'append (subst nil (list item) (mapcar 'list lst)))))
 
(if vl-remove-if
  (setq remove-if vl-remove-if)
  (defun remove-if (pred lst)
    (apply 'append
           (mapcar (function (lambda (x) (or (apply pred (list x)) (list x))))
                   lst))))
 
(if vl-remove-if-not
  (setq remove-if-not vl-remove-if-not)
  (defun remove-if-not (pred lst)
    (apply 'append
           (mapcar (function (lambda (x) (if (apply pred (list x)) (list x))))
                   lst))))
 
(if vle-remove-nth
  (setq remove-nth vle-remove-nth)
  (defun remove-nth (n lst)
    (setq lst (split-at n lst))
    (append (car lst) (cddr lst))))
 
(if vle-remove-first
  (setq remove-first vle-remove-first)
  (defun remove-first (item lst)
    (setq lst (split-at-first item lst))
    (append (car lst) (cddr lst))))
 
(if vle-remove-last
  (setq remove-last vle-remove-last)
  (defun remove-last (item lst)
    (setq lst (split-at-last item lst))
    (append (car lst) (cddr lst))))
 
(defun insert (new n lst)
  (setq lst (split-at n lst))
  (append (car lst) (cons new (cdr lst))))

dgorsman · « **Reply #5 on:** December 06, 2013, 10:19:00 AM »

The only way that is "wrong" is one that doesn't work. The shortest path is not the only way forward.

roy_043 · « **Reply #6 on:** December 06, 2013, 03:19:02 PM »

Quote from: divtiply on December 06, 2013, 09:25:22 AM

I'll give you a bit, tell me should I continue?

The fact that Reini Urban's project was abandoned more than 10 years ago (and not picked up by 'the community') should make you think, but is in itself no reason to stop working on your project.

Some random questions and remarks:
1.
Why look at CL? And if you are going to do that, why not make the (some) function really compatible.
2.
Consistent naming scheme? You now have predicate functions with names that do not end in '-p'.
3.
You are using vle-* functions. You should be aware that a non BricsCAD user may have loaded the complete vle-extension.lsp file. Which would result in a strange situation I think.
4.
Have you ever used the (tenth) function? Would some sort of (SafeNth) function not be more useful?
5.
You should be aware that writing code is but one part of the project. Testing, documentation, examples and maintenance are also required.
6.
Is the speed of the functions important? Or are you striving for 'elegant' code? See example below.

Code: [Select]

;;; (setq partLst '("a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"))
;;; (setq testLst (append partLst partLst '(0) partLst partLst))


;;; (KGX_BenchMark '((vl-some 'numberp testLst) (divtiply_some 'numberp testLst) (roy_some_1 'numberp testLst) (roy_some_2 'numberp testLst)) 5000)

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

      ; (VL-SOME 'NUMBERP TESTLST) ............ 16 / 8.81 <fastest>
      ; (ROY_SOME_2 'NUMBERP TESTLST) ......... 63 / 2.24
      ; (ROY_SOME_1 'NUMBERP TESTLST) ......... 93 / 1.52
      ; (DIVTIPLY_SOME 'NUMBERP TESTLST) ..... 141 / 1.00 <slowest>

Code - Auto/Visual Lisp: [Select]

; Code taken from the (some) function in divtiply's code)
(defun divtiply_some (pred lst / res)
  (while
    (and
      (setq res (not (apply pred (list (car lst)))))
      (setq lst (cdr lst))
    )
  )
  (not res)
)
 
; Some improvements:
(defun roy_some_1 (pred lst / res)
  (setq pred (eval pred))
  (while
    (and
      (not (setq res (pred (car lst))))
      (setq lst (cdr lst))
    )
  )
  res
)
 
; With additional speed improvement based on Reini Urban's (std-%setnth):
(defun roy_some_2 (pred lst / res)
  (setq pred (eval pred))
  (while
    (and
      (cadddr lst)
      (not
        (setq res
          (or
            (pred (car lst))
            (pred (cadr lst))
            (pred (caddr lst))
            (pred (cadddr lst))
          )
        )
      )
    )
    (setq lst (cddddr lst))
  )
  (if (not res)
    (while
      (and
        (car lst)
        (not (setq res (pred (car lst))))
      )
      (setq lst (cdr lst))
    )
  )
  res
)

divtiply · « **Reply #7 on:** December 06, 2013, 04:03:19 PM »

Quote from: roy_043 on December 06, 2013, 03:19:02 PM

Code: [Select]
; Some improvements:

Thanks Roy!
That's why I've started this topic. Together it's easy to improve common code.

Quote from: roy_043 on December 06, 2013, 03:19:02 PM

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

Which?

Jeff H · « **Reply #8 on:** December 06, 2013, 04:41:53 PM »

I have only played with AutoLisp here and there, but I will write the section on variable naming standards.

1. Do NOT be descriptive.
2. Try to keep variable names 3 letters or less.
3. Try to use a lower case 'l' as frequently as possible('l' is not the number one it is lowercase 'L').

Done.

divtiply · « **Reply #9 on:** December 06, 2013, 04:48:29 PM »

Quote from: Jeff H on December 06, 2013, 04:41:53 PM

1. Do NOT be descriptive.
2. Try to keep variable names 3 letters or less.
3. Try to use a lower case 'l' as frequently as possible('l' is not the number one it is lowercase 'L').

You prefer names like list-to-search-within instead of lst?

Jeff H · « **Reply #10 on:** December 06, 2013, 04:56:24 PM »

Hi divtiply,

That was not directed toward you or any code you posted. It was a joke from a non-lisper who is not familiar with the language or the conventions and seeing snippets of code with 'a', 'l', etc... as variables.

dgorsman · « **Reply #11 on:** December 06, 2013, 06:18:53 PM »

Quote from: Jeff H on December 06, 2013, 04:56:24 PM

Hi divtiply,

That was not directed toward you or any code you posted. It was a joke from a non-lisper who is not familiar with the language or the conventions and seeing snippets of code with 'a', 'l', etc... as variables.

Brought a smile to my face, at least.

danallen · « **Reply #12 on:** December 06, 2013, 07:05:16 PM »

does anyone have routines from Looking Glass Microproducts? I had collected some from the very old cad shack website and it was very useful for learning and putting together my own routines. (also probably was not legitimately shared though...

Quote from: LE on December 06, 2013, 09:21:21 AM

An ex-lisper comment:

In all my past years spent (20+-) in the autolisp/vlisp world --- the only way or form I have seen to adopt a function as standard it is when these are added into the autolisp core. Anything out it will be way too difficult - will only be part of anyone's personal functions arsenal. Have seen so many try-outs -- ALL have failed.

Let see if this time not.

LE!

LE3 · « **Reply #13 on:** December 06, 2013, 08:22:59 PM »

Quote from: danallen on December 06, 2013, 07:05:16 PM

does anyone have routines from Looking Glass Microproducts? I had collected some from the very old cad shack website and it was very useful for learning and putting together my own routines. (also probably was not legitimately shared though...

Oh!
The old master Phil Kreiker --- I remember those on cadence magazine? if my 1/4 brain cell left still is working.... I am sure he wrote the 'painter' or match properties --- too btw.

did a quick search and yes he had a section on cadalyst magazine named THE CAD COOKBOOK - so maybe if they are still available do a search on the cadalyst site.

ymg · « **Reply #14 on:** December 07, 2013, 02:50:55 AM »

Quote

For example, ymg's ceil/floor functions [http://www.theswamp.org/index.php?topic=45379.msg505421#msg505421]:

divtiply,

Thanks for the attribution, but these function were actually taken from std-math. http://autocad.xarch.at/stdlib/STDMATH.LSP

However I should have tested. (Post has been updated)

And by the way Floor and Ceiling are applicable to real numbers not to integers as shown in your example.

ymg

roy_043 · « **Reply #15 on:** December 07, 2013, 05:28:15 AM »

Quote from: divtiply on December 06, 2013, 04:03:19 PM

Quote from: roy_043 on December 06, 2013, 03:19:02 PM
2. Consistent naming scheme? You now have predicate functions with names that do not end in '-p'.
Which?

consp
some
every

divtiply · « **Reply #16 on:** December 07, 2013, 06:53:30 AM »

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

MP · « **Reply #17 on:** December 07, 2013, 07:41:11 AM »

Quote from: LE on December 06, 2013, 09:21:21 AM

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 · « **Reply #18 on:** December 07, 2013, 08:04:17 AM »

Quote from: divtiply on December 07, 2013, 06:53:30 AM

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

Quote from: roy_043 on December 06, 2013, 03:19:02 PM

1.
Why look at CL?

roy_043 · « **Reply #19 on:** December 07, 2013, 08:09:27 AM »

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]

(defun roy_some_2_Revised (pred lst / res)
  (setq pred (eval pred))
  (while
    (and
      (cadddr lst)
      (not
        (setq res
          (cond
            ((pred (car lst)))
            ((pred (cadr lst)))
            ((pred (caddr lst)))
            ((pred (cadddr lst)))
          )
        )
      )
    )
    (setq lst (cddddr lst))
  )
  (if (not res)
    (while
      (and
        (car lst)
        (not (setq res (pred (car lst))))
      )
      (setq lst (cdr lst))
    )
  )
  res
)

snownut2 · « **Reply #20 on:** December 07, 2013, 09:16:09 AM »

Roy,

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

Bruce

divtiply · « **Reply #21 on:** December 07, 2013, 11:34:18 AM »

Quote from: snownut2 on December 07, 2013, 09:16:09 AM

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

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

roy_043 · « **Reply #22 on:** December 07, 2013, 11:42:10 AM »

Quote from: snownut2 on December 07, 2013, 09:16:09 AM

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 · « **Reply #23 on:** December 07, 2013, 02:13:09 PM »

Roy,

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

Bruce

Jeremy · « **Reply #24 on:** December 07, 2013, 07:06:24 PM »

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 · « **Reply #25 on:** December 09, 2013, 03:56:22 AM »

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]

(defun roy_some_1_Revised_2 (pred lst / res)
  (setq pred (eval pred))
  (while
    (and
      (vl-consp lst)
      (not (setq res (pred (car lst))))
    )
    (setq lst (cdr lst))
  )
  res
)
 
(defun roy_some_2_Revised_2 (pred lst / res)
  (setq pred (eval pred))
  (while
    (and
      (vl-consp lst)
      (vl-consp (cdr lst))
      (vl-consp (cddr lst))
      (vl-consp (cdddr lst))
      (not
        (setq res
          (cond
            ((pred (car lst)))
            ((pred (cadr lst)))
            ((pred (caddr lst)))
            ((pred (cadddr lst)))
          )
        )
      )
    )
    (setq lst (cddddr lst))
  )
  (if (not res)
    (while
      (and
        (vl-consp lst)
        (not (setq res (pred (car lst))))
      )
      (setq lst (cdr lst))
    )
  )
  res
)

ymg · « **Reply #26 on:** December 09, 2013, 05:20:31 AM »

Here some revised ceil and floor function.

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

Code - Auto/Visual Lisp: [Select]

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

@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 · « **Reply #27 on:** December 09, 2013, 06:34:58 AM »

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 · « **Reply #28 on:** December 09, 2013, 07:39:32 AM »

Roy,

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

Bruce

roy_043 · « **Reply #29 on:** December 09, 2013, 10:29:28 AM »

Quote from: snownut2 on December 09, 2013, 07:39:32 AM

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.

ymg · « **Reply #30 on:** December 09, 2013, 02:51:37 PM »

divtiply,

I suggest you test your so called "correct implementation" of ceil and floor function.

Graph provided by omegatron at http://commons.wikimedia.org/wiki/File:Floor_function.svg
Ceiling Function:

Floor Function:

irneb · « **Reply #31 on:** December 10, 2013, 02:26:43 AM »

Had a similar idea a while back: http://www.theswamp.org/index.php?topic=39158.5

And yes CL, because it's the only one where the namings of functions (and their argument orders and expected results) is already well established in the hyperspec. If you go with something like Scheme, then you have an extremely small subset which is a prerequisite of functions R6RS - all the rest is up for grabs by the user (never mind the implementer). That means if you choose Scheme as a base (or some of the others like NewLisp) then you'd have to go through the entire process of choosing names, arguments, expected results, etc .... could be a very lengthy process especially as it would need consensus. Why not take one which has already gone through such process for several decades (i.e. Common Lisp)?

If you choose something like CL, then at least that portion is already sorted out. You can then focus on the actual implementations instead of arguing about the naming. Just my opinion

Edit: As per this discussion about floor/ceiling - http://www.lispworks.com/documentation/HyperSpec/Body/f_floorc.htm#floor

divtiply · « **Reply #32 on:** December 10, 2013, 10:23:40 AM »

Quote from: ymg on December 09, 2013, 02:51:37 PM

divtiply,
I suggest you test your so called "correct implementation" of ceil and floor function.

Oops. My optimizing went too far. Initial (and correct) versions was:

Code: [Select]

(defun floor (num / n)
  (if (zerop (- num (setq n (fix num))))
    n
    (if (minusp num) (1- n) n)))
(defun ceiling (num / n)
  (if (zerop (- num (setq n (fix num))))
    num
    (if (minusp num) n (1+ n))))

But your new code is faster.

LE3 · « **Reply #33 on:** December 10, 2013, 10:57:16 AM »

For what I see so far, it will take you guys a lot of time just to agree in these two common functions... I know it is not my business to make you change (and not my intention et-al).... But see how easy can be to use the Math function for example in lisp - No rocket science:

Code - C#: [Select]

        [LispFunction("Ceiling")]
        public object Swamp_Ceiling(ResultBuffer resultBuffer)
        {
            if (resultBuffer == null || resultBuffer.AsArray().Any(tv => tv.TypeCode != RTREAL)) return null;
            var number = (double)resultBuffer.AsArray().FirstOrDefault(tv => tv.TypeCode == RTREAL).Value;
            return Math.Ceiling(number);
        }
 
        [LispFunction("Floor")]
        public object Swamp_Floor(ResultBuffer resultBuffer)
        {
            if (resultBuffer == null || resultBuffer.AsArray().Any(tv => tv.TypeCode != RTREAL)) return null;
            var number = (double)resultBuffer.AsArray().FirstOrDefault(tv => tv.TypeCode == RTREAL).Value;
            return Math.Floor(number);
        }
 

Even if those are done in C++/ARX:

Code - C++: [Select]

        static int ads_ceil(void)
        {
                struct resbuf *rb = acedGetArgs();
                if (!rb) return RSERR;
                if (rb && rb->restype != RTREAL) { acutPrintf(_T("\nError: function requires a RTREAL as argument. \n")); return RSERR; }
                acedRetReal(ceil(rb->resval.rreal));
                return (RSRSLT);
        }
 
        static int ads_floor(void)
        {
                struct resbuf *rb = acedGetArgs();
                if (!rb) return RSERR;
                if (rb && rb->restype != RTREAL) { acutPrintf(_T("\nError: function requires a RTREAL as argument. \n")); return RSERR; }
                acedRetReal(floor(rb->resval.rreal));
                return (RSRSLT);
        }
 

Well I leave you guys here..... want to stay in the lisp world - good --- and yes autolisp it is GREAT --- but have his limitations.

See ya! and have fun.

ymg · « **Reply #34 on:** December 10, 2013, 12:47:55 PM »

Quote

Well I leave you guys here..... want to stay in the lisp world - good --- and yes autolisp it is GREAT --- but have his limitations.

Luis,

I agree that Autolisp has his limitations. (Just like me

)

As far as moving to the .net world, probably getting too old for that.

ARX and all these carry a lot of overhead for the kind of programming we do.
I won't even compile to a VLX.

Sorry if the thread has taken this tone, but Yes! I was peeved.

ymg

irneb · « **Reply #35 on:** December 10, 2013, 11:47:31 PM »

Quote from: LE on December 10, 2013, 10:57:16 AM

Well I leave you guys here..... want to stay in the lisp world - good --- and yes autolisp it is GREAT --- but have his limitations.

I'm not sure how you want us to take this. But your samples aren't showing how C#/C++ is "better" than AutoLisp. It's just showing that there are already libraries you can use built into it. It wasn't always the case, the Math lib was an addon to C++, prior to that C/C++ programmers had to roll their own Ceil/floor functions too (it was actually one of the exercises I had to do in my programming degree - implement some standard math functions as a library in C++).

This entire thread is actually about implementing those libs so us AutoLispers have the use of them as well (instead of needing to design our own).

roy_043 · « **Reply #36 on:** December 11, 2013, 05:04:26 AM »

To quote from a different topic:

Quote from: irneb on December 10, 2013, 11:36:29 PM

Quote from: Kerry on December 10, 2013, 06:42:48 PM

I look forward to seeing the implementation and documentation.
Yes, me too ... that is the main thing isn't it?

@ irneb and divtiply:
What would it take to get this off the ground?

LE3 · « **Reply #37 on:** December 11, 2013, 01:20:24 PM »

Quote from: irneb on December 10, 2013, 11:47:31 PM

This entire thread is actually about implementing those libs so us AutoLispers have the use of them as well (instead of needing to design our own).

My point is to take advantage of what it is available - I come from a background in lisp too.

I just did an startup visual studio solution on my lunch break to export some of the Math library methods as autolisp functions, will open a new topic on the show your stuff and post the link later today here...

Have fun.

Edit: Here it is the link for my test project:
http://www.theswamp.org/index.php?topic=45841.msg509847#msg509847

irneb · « **Reply #38 on:** December 12, 2013, 12:14:44 AM »

Quote from: roy_043 on December 11, 2013, 05:04:26 AM

@ irneb and divtiply:
What would it take to get this off the ground?

Many things

most notably:

Someone (or rather more than one, or preferably some form of "organization") to take ownership of this.
A forum to propose new functions / items for inclusion to this library. Also to discuss & vote on these functions. Note if CL is used as a benchmark, much of this is already done for us - it's been tweaked since the '80s, so chances are that quite a lot of thought has already been incorporated
Some method of listing the accepted functions for inclusion, perhaps just a wiki page which could be the start of documentation
Another forum where implementations are proposed, discussed, "better" alternatives suggested and voted on.
A site where the latest version can easily be downloaded. This should also include a wiki-like documentation which can be downloaded to a local off-line file. Another reason CL is a good choice: much of the documentation is already in the hyperspec
A "would be nice to have" is also some buy-in from the manufacturers of the programs where AutoLisp features as an extension language. i.e. AutoCAD, BricsCAD and other similar clones. But, this is not a necessity, as most of the lib can be implemented as normal Lisp defuns instead of needing built-in additions. Further, most of these also provide other ways to add Lisp functions, like ARX/BRX, or even just through DotNet.

The list is probably not complete, but I think it shows the main hurdles to navigate.

If you guys feel creating a new project just for this is over the top, then feel free to join my Caddons project. I've already added some library functions there, together with some tools for use. It's just that I don't have the time to constantly give it the attention needed for such an undertaking on my own. It has a wiki built-in, as well as a forum for proposing "feature requests", bug reports and a general discussion.

Alternative (or in addition to) I've also started a wiki for listing possible extensions to AutoLisp, though its main aim is to revamp the entire Lisp engine to turn it into a much more powerful Lisping environment (perhaps a bit in excess of what this thread is about): http://alisp-ext.wikidot.com/

Quote from: LE on December 11, 2013, 01:20:24 PM

...I come from a background in lisp too...

Actually I came from the other side: Basic, Pascal, Java & C++ first, AutoLisp became like a drug after that, then I started looking at all the other Lisps and literally (note TRUE use of the word) fell in love with it. Thanks I'll take a look at that thread also.

Jeff H · « **Reply #39 on:** December 12, 2013, 01:37:32 AM »

Quote from: irneb on December 12, 2013, 12:14:44 AM

... < >

I wish I knew where to GIT that.

stuffed up by kerry:
I wish I'd said that

Oooops, I really stuffed that up .. sorry Jeff

LE3 · « **Reply #40 on:** December 12, 2013, 09:19:27 AM »

Quote from: irneb on December 12, 2013, 12:14:44 AM

Actually I came from the other side: Basic, Pascal, Java & C++ first, AutoLisp became like a drug after that, then I started looking at all the other Lisps and literally (note TRUE use of the word) fell in love with it. Thanks I'll take a look at that thread also.

Wow --- That's interesting - Hope and guess you still use at least the C++ and have that advantage. I am glad that I am out of lisp as I used to.... still can do some minor stuff when needed.
Have fun!

irneb · « **Reply #41 on:** December 13, 2013, 12:49:35 AM »

Quote from: LE on December 12, 2013, 09:19:27 AM

Wow --- That's interesting - Hope and guess you still use at least the C++ and have that advantage. I am glad that I am out of lisp as I used to.... still can do some minor stuff when needed.
Have fun!

Actually I despised C++, I try to avoid it as much as possible - did then (mid '90s) and still feel the same. I actually preferred Java and Pascal, so C# came nearly naturally to me (it's so close to Java as to make next to no difference). None of them (however) gives me the same sense of accomplishment through absolute minimum input that Lisp does. But that's just me.

Marc'Antonio Alessi · « **Reply #42 on:** December 13, 2013, 03:32:26 AM »

Quote from: irneb on December 13, 2013, 12:49:35 AM

Actually I despised C++, I try to avoid it as much as possible - did then (mid '90s) and still feel the same. I actually preferred Java and Pascal, so C# came nearly naturally to me (it's so close to Java as to make next to no difference). None of them (however) gives me the same sense of accomplishment through absolute minimum input that Lisp does. But that's just me.

I think it is a very widespread opinion, this is also one of the reasons for the success of Bricscad and their effort to make it compatible the maximum possible with VisualLisp. This is also demonstrated by the number of topics:

Code: [Select]

Posts            TheSwamp
-------------------------
AutoLISP (Visual)   76919
VB(A)                8467
.NET                24517
ARX Programming      2745
General Programming  7244

Topics           TheSwamp  Autodesk
-----------------------------------
AutoLISP (Visual)    6831      1842
VB(A)                 910       801
.NET                 2774       271
ARX Programming       335       304
General Programming   783

It seems that the topics of Autodesk begin by 1999, but many have been lost, especially of AutoLISP.

LE3 · « **Reply #43 on:** December 13, 2013, 09:30:35 AM »

OK, the link for some other option to use, it is there now, it have also some more information provided by Gile too. LE!

ymg · « **Reply #44 on:** December 13, 2013, 12:55:02 PM »

Quote

Actually I despised C++, I try to avoid it as much as possible - did then (mid '90s) and still feel the same.

You can count me in in the group that love to hate C++.

Now, If we could get optional argument to function and array (Not the monster we got now).....!

ymg

Jeff H · « **Reply #45 on:** December 13, 2013, 02:26:17 PM »

Most people think C++ 11 code is C#.

Why not use well tested and efficient designed algorithms from communities with many more users and money to create them.

When LE exported Math functions to AutoLisp he just gave access to methods that have been used and tested by millions of people, countless hours of math and computer nerds analyzing it.

Nothing anyone said here but seems like people perceptions of other languages are based on AutoCAD's API for that language.

hawstom · « **Reply #46 on:** March 13, 2017, 01:39:27 PM »

Blink and it's 2017.

I think this is worth whatever effort it takes. I see room for a few competing libraries. But the key is that they are community projects, which has not yet happened.

I'm not so opinionated as to care a lot whether the first success looks a lot like the efforts of LE3, divtiply, roy_43, or something else. Or whether it builds on CL or Reini Urban's work (though building on the best foundation is probably smart).

I am guessing we just have to keep talking until we can get at least a few of us diverse and strong-minded folks to unite behind something and then listen and invite and evangelize like crazy. Let's keep talking. I am in this for the long haul (not looking to retire or die soon).

News:

Author Topic: Well tested common functions library - should we have it? (Read 16490 times)

divtiply

divtiply

LE3

divtiply

divtiply

divtiply

danallen

LE3

ymg

divtiply

divtiply

Jeremy

ymg

ymg

divtiply

LE3

ymg

LE3

LE3

LE3

ymg