1. 25 Jan, 2018 1 commit
    • Mark Olesen's avatar
      ENH: allow early completion in PackedBoolList::used() · 7ee93afe
      Mark Olesen authored
      - can stop producing content when the target number of entries has
        been reached.
      
      - change return type to labelList instead an Xfer container.
        This allows return-value-optimization and avoids a surrounding
        allocation. This potentially breaks existing code.
      
      - make PackedList and PackedBoolList moveable. Drop xfer wrappers.
      7ee93afe
  2. 04 Jan, 2018 1 commit
  3. 19 Nov, 2017 1 commit
  4. 07 Oct, 2017 1 commit
  5. 26 May, 2017 2 commits
  6. 08 Feb, 2017 1 commit
  7. 06 May, 2016 1 commit
  8. 28 Feb, 2016 1 commit
  9. 17 Jan, 2016 1 commit
  10. 10 Jan, 2016 1 commit
  11. 08 Nov, 2015 1 commit
  12. 14 Feb, 2012 1 commit
  13. 14 Aug, 2011 1 commit
  14. 19 Jan, 2011 1 commit
  15. 14 Jan, 2011 1 commit
  16. 07 Jan, 2011 1 commit
  17. 05 Jan, 2011 2 commits
  18. 02 Nov, 2010 1 commit
  19. 04 Oct, 2010 1 commit
  20. 16 Sep, 2010 2 commits
  21. 15 Sep, 2010 1 commit
    • Mark Olesen's avatar
      ENH: added binary IO for PackedList and compact ASCII format · b7c85357
      Mark Olesen authored
      The compact ASCII format is a block of index/value tuples for the
      non-zero entries:
      
          { (index1 value1) (index2 value2) (index3 value3) }
      
      For PackedList<1>, and thus PackedBoolList, the compact ASCII format is
      a block of indices for the non-zero entries:
      
          { index1 index2 index3 }
      
      Thus either of the following could be used - for PackedList<2>:
      
        - a list of all values:
              16(0 3 0 2 0 0 3 1 0 0 0 0 0 0 0 1)
      
        - a block of index/value tuples:
              {(1 3) (3 2) (7 3) (8 1) (15 1)}
      
      For PackedList<1> and PackedBoolList, either of the following could be
      used:
      
        - a list of all values, using any valid bool representation:
              16(0 1 0 true 0 0 t 1 0 n n 0 0 0 0 yes)
      
        - a block of the indices for non-zero entries:
              {1 3 7 8 15}
      b7c85357
  22. 28 Jul, 2010 2 commits
  23. 29 Mar, 2010 1 commit
  24. 15 Jan, 2010 1 commit
  25. 08 Dec, 2009 2 commits
    • Mark Olesen's avatar
      HashSet and PackedList get an unset() method · d2d39c32
      Mark Olesen authored
      - provides a convenient (and lazy) means of removing entries
      d2d39c32
    • Mark Olesen's avatar
      Applied Mattijs' PackedList improvements · 16c715ce
      Mark Olesen authored
      - resize with factor 2 as per DynamicList
      
      Old insertion speed:
          1000000 in 0.61 s
          2000000 in 2.24 s
          3000000 in 3.97 s
          4000000 in 5.76 s
          5000000 in 7.54 s
          6000000 in 9.41 s
          7000000 in 11.5 s
      
      New insertion speed:
          1000000 in 0.01 s
          2000000 in 0.02 s
          3000000 in 0.01 s
          4000000 in 0.02 s
          5000000 in 0.01 s
          6000000 in 0.01 s
          7000000 in 0.01 s
      16c715ce
  26. 07 Dec, 2009 1 commit
  27. 03 Dec, 2009 1 commit
    • Mark Olesen's avatar
      PackedBoolList specializaton for operator= · 063d8ede
      Mark Olesen authored
      - now that I re-examined the code, the note in commit 51fd6327
        can be mostly ignored
      
        PackedList isMaster(nPoints, 1u);
        is not really inefficient at all, since the '1u' is packed into
        32/64-bits before the subsequent assignment and doesn't involve
        shifts/masking for each index
      
        The same misinformation applies to the PackedList(size, 0u) form.
        It isn't much slower at all.
      
        Nonetheless, add bool specialization so that it is a simple assign.
      063d8ede
  28. 23 Jul, 2009 2 commits
  29. 12 Mar, 2009 1 commit
  30. 27 Feb, 2009 2 commits
    • mattijs's avatar
      operator== on result of operator[] behaves weird · 0f7b03e6
      mattijs authored
      0f7b03e6
    • Mark Olesen's avatar
      PackedList iterator bugfix · dbc9b742
      Mark Olesen authored
      - compare iteratorBase == iteratorBase by value, not position
        thus this works
            list[a] == list[b] ...
      
      - compare iterator == iteratorBase and const_iterator == iteratorBase
        by position, not value. The inheritance rules means that this works:
            iter == list.end() ...
        this will compare positions:
            iter == list[5];
        Of course, this will still compare values:
            *iter == list[5];
      dbc9b742
  31. 29 Jan, 2009 3 commits
    • Mark Olesen's avatar
      PackedList - activated lazy evaluation · 1f6733d9
      Mark Olesen authored
      - moving back to original flat addressing in iterators means there is no
        performance issue with using lazy evaluation
      - set() method now has ~0 for a default value.
        We can thus simply write 'set(i) to trun on all of the bits.
        This means we can use it just like labelHashSet::set(i)
      - added flip() method for inverting bits. I don't know where we might need
        it, but the STL has it so we might as well too.
      1f6733d9
    • Mark Olesen's avatar
      PackedList with unsigned template parameter · 55d4fb2e
      Mark Olesen authored
      55d4fb2e
    • Mark Olesen's avatar
      PackedList improvements · 4e56643e
      Mark Olesen authored
      - dropped auto-vivification for now (performance issue), but reworked to
        allow easy reinstatement
      - derived both iterator and const_iterator from iteratorBase and use
        iteratorBase as our proxy for non-const access to the list elements.
        This allows properly chaining assignments:
           list[1] = list[2];
           list[1] = list[2] = 10;
      - assigning iterators from iteratorBase or other iterators works:
           iterator iter = list[20];
      - made template parameter nBits=1 the default
      4e56643e