[sicl-cvs] GIT update: SICL, bricks for implementors of Common Lisp systems. branch, master, updated. c908a4647626b56aa21fb83a6a5058e83aada7e2

[Robert Strandh]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "SICL, bricks for implementors of Common Lisp systems. ".

The branch, master has been updated
       via  c908a4647626b56aa21fb83a6a5058e83aada7e2 (commit)
      from  8e2ba58ac3a3fcbbb8a7b9ec3f00fb3822dbfb93 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit c908a4647626b56aa21fb83a6a5058e83aada7e2
Author: Robert Strandh <strandh at Sicl.(none)>
Date:   Sat Dec 4 17:06:53 2010 +0100

    New method for traversing lists from the end, which is required by
    some sequence functions, in particular count when from-end is true.
    This method uses recursion, and traverses during backtrack, but it
    limits the stack depth to some fixed amount that can be set for
    each implementation.
    
    Modified existing specialized versions of count to take advantage of
    the new method.  Some of them were correct in that they traversed from
    end, using an auxiliary vector.  Some of them were wrong, because they
    would scan from start to end even though key=other, so the key
    function could have side effects, and so scanning from start to end
    would have been a violation of the standard.
    
    This new method gives us a very fast version of count when from-end is
    true and either key is not identity or either test or test-not is
    neither eql nor eq, i.e., when the test and/or the key might have side
    effects.  We have observed execution times of only 1/3 of those of
    SBCL on long lists.
    
    Even though there is no requirement that the list be scanned from the
    end when from-end is true in functions such as find, scanning from the
    beginning can be penalizing when the test and/or the key functions are
    costly to execute.  We might use our new method for those cases as
    well, thus potentially saving a lot when the item looked for is close
    to the end of the list.
    
    More utility functions to use at the end of lists.
    
    More renamings in order that the code conform to recent naming
    conventions.
    
    The entire code is in a limbo now.  Many tests fail.  This is work in
    progress to get it back into a reasonable state.

-----------------------------------------------------------------------

Summary of changes:
 Code/Sequences/sequences.lisp | 3911 ++++++++++++++++++-----------------------
 1 files changed, 1758 insertions(+), 2153 deletions(-)


hooks/post-receive
-- 
SICL, bricks for implementors of Common Lisp systems.