• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            Life is Good.

            Enhance Tech and English
            隨筆 - 65, 文章 - 20, 評論 - 21, 引用 - 0
            數據加載中……

            Boosting Lisp performance - cons vs append and foreach vs while/nth

            From our PD- Nate Holt:

            All,

             More and more of you are finding that you have to deal with this goofy language called AutoLISP. Here are a couple items I pulled together related to some lisp “best practices”. Both apply to optimizing performance when processing large “lists” of data.

            Thanks,

            Nate.

                CONS versus APPEND

            The cons function adds an element to the beginning of a list. The append function can be used to give the equivalent of adding an element to the beginning or end of a list.

            Using the cons function can be MUCH faster than using append to build up a large list.

            We'll run two tests to create a dummy list of 10,000 integer numbers. The first test is using the "cons" function. Appload and type test1 [enter] at the command prompt.

            (defun c:test1 ( / )
              (setq i 1)
              (setq lst nil) ; start out with a blank list
              (repeat 10000
                (setq lst (cons i lst)) ; add next element to beginning of list
                (setq i (1+ i))
              )
              (setq lst (reverse lst)) ; put list back into correct order
              (princ)
            )

            The second test yields the same result but uses the "append" function:

            (defun c:test2 ( / )
              (setq i 1)
              (setq lst nil) ; start out with a blank list
              (repeat 10000
                (setq lst (append lst (list i))) ; append next element on to end of list
                (setq i (1+ i))
              )
              (princ)
            )

            The first test using "cons" builds the 10,000 element list in memory in less than 0.01 seconds (on my T61p).The second test using "append" builds the exact same 10,000 element list in memory but takes a full 3.55 seconds to execute ( ! ). Dealing with large lists, it appears that the "cons" function is many, many times faster.

            ·         FOREACH versus WHILE / NTH

            Let's say you need to cycle through a huge list, one list element at a time. There are two different functions that can cycle through a list, "foreach" and "nth" combined with a "while" loop. When dealing with a very large list, the "foreach" function can be much faster than using a while loop / nth function to index through the list.

            These tests use the 10,000 element list held in memory created be either of the above two tests. This next test uses "foreach" to cycle through the 10,000 element list.

            (defun c:test3 ( / )
              ; use 10,000 element "lst" created by test1 or test2
              (setq find_int (getint "\nFind integer="))
              (setq foundit nil)
              (foreach x lst
                (if (AND (not foundit) (= x find_int))
                  (progn
                    (setq foundit T)
                    (princ " found") 
                ) )   
              )
              (princ)
            )

            This next test does the same thing but uses a "while" loop and the "nth" function to index its way through the 10,000 element list:

            (defun c:test4 ( / )
              ; use 10,000 element "lst" created by test1 or test2
              (setq find_int (getint "\nFind integer="))
              (setq foundit nil)
              (setq ix 0)
              (setq slen (length lst))
              (while (AND (not foundit)(< ix slen))
                (if (= (nth ix lst) find_int) ; look for match
                  (progn ; Found the target element
                    (setq foundit T)
                    (princ " found") 
                ) )
                (setq ix (1+ ix))  
              )
              (princ)
            )

            For the test, looking for integer value 5000 (halfway into the list). The "foreach" function finds and exits in less than 0.01 second. The while loop using the "nth" function finds and exits in 0.07 seconds. Using foreach is significantly faster in processing this large list.

            posted on 2008-11-10 10:49 Mike Song 閱讀(353) 評論(0)  編輯 收藏 引用

            九九久久自然熟的香蕉图片| 久久99精品国产麻豆宅宅| 久久国产V一级毛多内射| 国产午夜精品理论片久久影视 | 狠狠久久亚洲欧美专区| 97久久超碰成人精品网站| 久久免费小视频| 亚洲综合久久久| 国产69精品久久久久777| 久久亚洲av无码精品浪潮| 色欲av伊人久久大香线蕉影院| 狠狠色婷婷久久一区二区三区| 久久免费国产精品| 欧美牲交A欧牲交aⅴ久久| 久久精品人妻一区二区三区| 亚洲国产精品无码久久久秋霞2| 日本久久久久久中文字幕| 色妞色综合久久夜夜| 久久综合九色综合精品| 亚洲色欲久久久综合网| 精品国产综合区久久久久久| 久久这里只有精品18| 2019久久久高清456| 久久www免费人成精品香蕉| 97热久久免费频精品99| 精品熟女少妇AV免费久久| 久久九色综合九色99伊人| 亚洲午夜久久影院| 精品久久久久久国产91| 久久久久亚洲av无码专区喷水| 久久久国产99久久国产一| 成人亚洲欧美久久久久| 久久精品人人做人人爽97| 久久综合香蕉国产蜜臀AV| 久久人妻无码中文字幕| 久久这里的只有是精品23| 少妇久久久久久被弄到高潮| 久久久久久A亚洲欧洲AV冫| 久久国产成人亚洲精品影院| 狠狠色综合久久久久尤物| 国产精品xxxx国产喷水亚洲国产精品无码久久一区 |