123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763 |
- =======================
- Release notes for bcolz
- =======================
- Changes from 1.1.0 to 1.1.1
- ===========================
- - Allow to delete all the columns in a ctable. Fixes #306.
- - Double-check the value of a column that is being overwritten. Fixes
- #307.
- - Now all the columns in a ctable are enforced to be a carray instance
- in order to simplify the internal logic for handling columns.
- - Now, the cparams are preserved during column replacement, e.g.:
- `ct['f0'] = x + 1`
- - C-Blosc updated to 1.9.3.
- - Added a new `defaults_ctx` context so that users can select defaults
- easily without changing global behaviour. For example::
- with bcolz.defaults_ctx(vm="python", cparams=bcolz.cparams(clevel=0)):
- cout = bcolz.eval("(x + 1) < 0")
- Changes from 1.0.0 to 1.1.0
- ===========================
- - Defaults when creating carray/ctable objects are always scalars now.
- The new approach follows what was documented and besides it prevents
- storing too much JSON data in meta/ directory.
- - Fixed an issue with bcolz.iterblocks() not working on multidimensional
- carrays.
- - It is possible now to create ctables with more than 255 columns. Thanks
- to Skipper Seabold. Fixes #131 (via PR #303).
- - Added a new `quantize` filter for allowing lossy compression on
- floating point data. Data is quantized using
- np.around(scale*data)/scale, where scale is 2**bits, and bits is
- determined from the quantize value. For example, if quantize=1, bits
- will be 4. 0 means that the quantization is disabled.
- Here it is an example of what you can get from the new quantize::
- In [9]: a = np.cumsum(np.random.random_sample(1000*1000)-0.5)
- In [10]: bcolz.carray(a, cparams=bcolz.cparams(quantize=0)) # no quantize
- Out[10]:
- carray((1000000,), float64)
- nbytes: 7.63 MB; cbytes: 6.05 MB; ratio: 1.26
- cparams := cparams(clevel=5, shuffle=1, cname='blosclz', quantize=0)
- [ -2.80946077e-01 -7.63925274e-01 -5.65575047e-01 ..., 3.59036158e+02
- 3.58546624e+02 3.58258860e+02]
- In [11]: bcolz.carray(a, cparams=bcolz.cparams(quantize=1))
- Out[11]:
- carray((1000000,), float64)
- nbytes: 7.63 MB; cbytes: 1.41 MB; ratio: 5.40
- cparams := cparams(clevel=5, shuffle=1, cname='blosclz', quantize=1)
- [ -2.50000000e-01 -7.50000000e-01 -5.62500000e-01 ..., 3.59036158e+02
- 3.58546624e+02 3.58258860e+02]
- In [12]: bcolz.carray(a, cparams=bcolz.cparams(quantize=2))
- Out[12]:
- carray((1000000,), float64)
- nbytes: 7.63 MB; cbytes: 2.20 MB; ratio: 3.47
- cparams := cparams(clevel=5, shuffle=1, cname='blosclz', quantize=2)
- [ -2.81250000e-01 -7.65625000e-01 -5.62500000e-01 ..., 3.59036158e+02
- 3.58546624e+02 3.58258860e+02]
- In [13]: bcolz.carray(a, cparams=bcolz.cparams(quantize=3))
- Out[13]:
- carray((1000000,), float64)
- nbytes: 7.63 MB; cbytes: 2.30 MB; ratio: 3.31
- cparams := cparams(clevel=5, shuffle=1, cname='blosclz', quantize=3)
- [ -2.81250000e-01 -7.63671875e-01 -5.65429688e-01 ..., 3.59036158e+02
- 3.58546624e+02 3.58258860e+02]
- As you can see, the compression ratio can improve pretty significantly
- when using the quantize filter. It is important to note that by using
- quantize you are loosing precision on your floating point data.
- Also note how the first elements in the quantized arrays have less
- significant digits, but not the last ones. This is a side effect due
- to how bcolz stores the trainling data that do not fit in a whole
- chunk. But in general you should expect a loss in precision.
- - Fixed a bug in carray.__getitem__() when the chunksize was not an
- exact multiple of the blocksize. Added test:
- test_carray.py::getitemMemoryTest::test06.
- - bcolz now follows the convention introduced in NumPy 1.11 for
- representing datetime types with TZ="naive" (i.e. with no TZ info in
- the representation). See https://github.com/numpy/numpy/blob/master/doc/release/1.11.0-notes.rst#datetime64-changes.
- - bcolz now releases the GIL during Blosc compression/decompression. In
- multi-threaded environments, a single-threaded, contextual version of
- Blosc is used instead (this is useful for frameworks like Dask).
- - Removed from the ``cbytes`` count the storage overhead due to the
- internal container. This overhead was media-dependent, and it was
- just a guess anyway.
- - The -O1 compilation flag has been removed and bcolz is compiled now at
- full optimization. I have tested that for several weeks, without any
- segfault, so this should be pretty safe.
- - Added information about the chunklen, chunksize and blocksize (the
- size of the internal blocks in a Blosc chunk) in the repr() of a
- carray.
- - New accelerated codepath for `carray[:] = array` assignation. This
- operation should be close in performance to `carray.copy()` now.
- - carray object does implement the __array__() special method
- (http://docs.scipy.org/doc/numpy-1.10.1/reference/arrays.classes.html#numpy.class.__array__)
- now. With this, interoperability with numpy arrays is easier and
- faster:
- Before __array__()::
- >>> a = np.arange(1e7)
- >>> b = np.arange(1e7)
- >>> ca = bcolz.carray(a)
- >>> cb = bcolz.carray(b)
- >>> %timeit ca + a
- 1 loop, best of 3: 1.06 s per loop
- >>> %timeit np.array(bcolz.eval("ca*(cb+1)"))
- 1 loop, best of 3: 1.18 s per loop
- After __array__()::
- >>> %timeit ca + a
- 10 loops, best of 3: 45.2 ms per loop
- >>> %timeit np.array(bcolz.eval("ca*(cb+1)"))
- 1 loop, best of 3: 133 ms per loop
- And it also allows to use bcolz carrays more efficiently in some scenarios::
- >>> import numexpr
- >>> %timeit numexpr.evaluate("ca*(cb+1)")
- 10 loops, best of 3: 76.2 ms per loop
- >>> %timeit numexpr.evaluate("a*(b+1)")
- 10 loops, best of 3: 25.5 ms per loop # ndarrays are still faster
- - Internal C-Blosc sources bumped to 1.9.2.
- - Dask (dask.pydata.org) is supported as another virtual machine backed
- for bcolz.eval(). Now, either Numexpr (the default) or Dask or even
- the Python interpreter can be used to evaluate complex expressions.
- - The default compressor has been changed from 'blosclz' to 'lz4'.
- BloscLZ tends to be a bit faster when decompressing, but LZ4 is
- quickly catching up as the compilers are making progress with memory
- access optimizations. Also, LZ4 is considerably faster during
- compression and in general compresses better too.
- - The supported SIMD extensions (SSE2 and AVX2) of the current platform
- are auto-detected so that the affected code will selectively be
- included from vendored C-Blosc sources.
- - Added a new `blen` parameter to bcolz.eval() so that the user can
- select the length of the operand blocks to be operated with.
- - New fine-tuning of the automatically computed blen in bcolz.eval() for
- better times and reduced memory consumption.
- - Added a new `out_flavor` parameter to the ctable.iter() and
- ctable.where() for specifying the type of result rows. Now one can
- select namedtuple (default), tuple or ndarray.
- - The performance of carray.whereblocks() has been accelerated 2x due to
- the internal use of tuples instead of named tuples.
- - New ctable.fetchwhere() method for getting the rows fulfilling some
- condition in one go.
- - Parameter `outfields` in ctable.whereblocks has been renamed to
- `outcols` for consistency with the other methods. The previous
- 'outfields' name is considered a bug and hence is not supported
- anymore.
- - bcolz.fromiter() has been streamlined and optimized. The result is
- that it uses less memory and can go faster too (20% ~ 50%, depending
- on the use).
- - The values for defaults.eval_out_flavor has been changed to ['bcolz',
- 'numpy'] instead of previous ['carray', 'numpy']. For backward
- compatibility the 'carray' value is still allowed.
- - The `bcolz.defaults.eval_out_flavor` and `bcolz.defaults.eval_vm` have
- been renamed to `bcolz.defaults.out_flavor` and `bcolz.defaults.vm`
- because they can be used in other places than just bcolz.eval(). The
- old `eval_out_flavor` and `eval_vm` properties of the `defaults`
- object are still kept for backward compatibility, but they are not
- documented anymore and its use is discouraged.
- - Added a new `user_dict` parameter in all ctable methods that evaluate
- expressions. For convenience, this dictionary is updated internally
- with ctable columns, locals and globals from the caller.
- - Small optimization for using the recently added re_evaluate() function
- in numexpr for faster operation of numexpr inside loops using the same
- expression (quite common scenario).
- - Unicode strings are recognized now when imported from a pandas
- dataframe, making the storage much more efficient. Before unicode was
- converted into 'O'bject type, but the change to 'U'nicode should be
- backward compatible.
- - Added a new `vm` parameter to specify the virtual machine for doing
- internal operations in ctable.where(), ctable.fetchwhere() and
- ctable.whereblocks().
- Changes from 0.12.1 to 1.0.0
- ============================
- - New version of embedded C-Blosc (bumped to 1.8.1). This allows for
- using recent C-Blosc features like the BITSHUFFLE filter that
- generally allows for better compression ratios at the expense of some
- slowdown. Look into the carray tutorial on how to use the new
- BITSHUFFLE filter.
- - Use the -O1 flag for compiling the included C-Blosc sources on Linux.
- This represents slower performance, but fixes nasty segfaults as can
- be seen in issue #110 of python-blosc. Also, it prints a warning for
- using an external C-Blosc library.
- - Improved support for operations with carrays of shape (N, 1). PR #296.
- Fixes #165 and #295. Thanks to Kevin Murray.
- - Check that column exists before inserting a new one in a ctable via
- `__setitem__`. If it exists, the existing column is overwritten.
- Fixes #291.
- - Some optimisations have been made within ``carray.__getitem__`` to
- improve performance when extracting a slice of data from a
- carray. This is particularly relevant when running some computation
- chunk-by-chunk over a large carray. (#283 @alimanfoo).
- Changes from 0.12.0 to 0.12.1
- =============================
- - ``setup.py`` now defers operations requiring ``numpy`` and ``Cython``
- until after those modules have been installed by ``setuptools``. This
- means that users no longer need to pre-install ``numpy`` and
- ``Cython`` to install ``bcolz``.
- Changes from 0.11.4 to 0.12.0
- =============================
- - Fixes an installation glitch for Windows. (#268 @cgohlke).
- - The tutorial is now a Jupyter notebook. (#261 @FrancescElies).
- - Replaces numpy float string specifier in test with numpy.longdouble
- (#271 @msarahan).
- - Fix for allowing the use of variables of type string in `eval()` and
- other queries. (#273, @FrancescAlted).
- - The size of the tables during import/export to HDF5 are honored now
- via the `expectedlen` (bcolz) and `expectedrows` (PyTables)
- parameters (@FrancescAlted).
- - Update only the valid part of the last chunk during boolean
- assignments. Fixes a VisibleDeprecationWarning with NumPy 1.10
- (@FrancescAlted).
- - More consistent string-type checking to allow use of unicode strings
- in Python 2 for queries, column selection, etc. (#274 @BrenBarn).
- - Installation no longer fails when listed as dependency of project
- installed via setup.py develop or setup.py install. (#280 @mindw,
- fixes #277).
- - Paver setup has been deprecated (see #275).
- Changes from 0.11.3 to 0.11.4
- =============================
- - The .pyx extension is not packed using the absolute path anymore.
- (#266 @FrancescAlted)
- Changes from 0.11.2 to 0.11.3
- =============================
- - Implement feature #255 bcolz.zeros can create new ctables too, either
- empty or filled with zeros. (#256 @FrancescElies @FrancescAlted)
- Changes from 0.11.1 to 0.11.2
- =============================
- - Changed the `setuptools>18.3` dependency to `setuptools>18.0` because
- Anaconda does not have `setuptools > 18.1` yet.
- Changes from 0.11.0 to 0.11.1
- =============================
- - Do not try to flush when a ctable is opened in 'r'ead-only mode.
- See issue #252.
- - Added the mock dependency for Python2.
- - Added a `setuptools>18.3` dependency.
- - Several fixes in the tutorial (Francesc Elies).
- Changes from 0.10.0 to 0.11.0
- =============================
- - Added support for appending a np.void to ctable objects
- (closes ticket #229 @eumiro)
- - Do not try to flush when an carray is opened in 'r'ead-only mode.
- (closes #241 @FrancescAlted).
- - Fix appending of object arrays to already existing carrays
- (closes #243 @cpcloud)
- - Great modernization of setup.py by using new versioning and many
- other improvements (PR #239 @mindw).
- Changes from 0.9.0 to 0.10.0
- ============================
- - Fix pickle for in-memory carrays. (#193 #194 @dataisle @esc)
- - Implement chunks iterator, which allows the following syntax
- ``for chunk_ in ca._chunks``, added "internal use" indicator to carray
- chunks attribute. (#153 @FrancescElies and @esc)
- - Fix a memory leak and avoid copy in ``chunk.getudata``. (#201 #202 @esc)
- - Fix the error message when trying to open a fresh ctable in an existing
- rootdir. (#191 @twiecki @esc)
- - Solve #22 and be more specific about ``carray`` private methods.
- (#209 @FrancescElies @FrancescAlted)
- - Implement context manager for ``carray`` and ``ctable``.
- (#135 #210 @FrancescElies and @esc)
- - Fix handling and API for leftovers. (#72 #132 #211 #213 @FrancescElies @esc)
- - Fix bug for incorrect leftover value. (#208 @waylonflinn)
- - Documentation: document how to write extensions, update docstrings and
- mention the with statement / context manager. (#214 @FrancescElies)
- - Various refactorings and cleanups. (#190 #198 #197 #199 #200)
- - Fix bug creating carrays from transposed arrays without explicit dtype.
- (#217 #218 @sdvillal)
- Changes from 0.8.1 to 0.9.0
- ===========================
- - Implement ``purge``, which removes data for on-disk carrays. (#130 @esc)
- - Implement ``addcol/delcol`` to properly handle on-disk ctable (#112/#151 @cpcloud @esc)
- - Adding io-mode to the ``repr`` for carrays. (#124 @esc)
- - Implement ``auto_flush`` which allows ctables to flush themselves during
- operations that modify (write) data.
- (#140 #152 @FrancescElies @CarstVaartjes @esc)
- - Implement ``move`` for ctable, which allows disk-based carray to be moved
- (``mv``) into the root directory of the ctable.
- (#140 #152 #170 @FrancescElies @CarstVaartjes @esc)
- - Distribute ``carray_ext.pxd`` as part of the package. (#159 @ARF)
- - Add ``safe=`` keyword argument to control dtype/stride checking on append
- (#163 @mrocklin)
- - Hold GIL during c-blosc compression/decompression, avoiding some segfaults
- (#166 @mrocklin)
- - Fix ``dtype`` for multidimensional columns in a ctable (#136 #172 @alimanfoo)
- - Fix to allow adding strings > len 1 to ctable (#178 @brentp)
- - Sphinx based API documentation is now built from the docstrings in the Python
- sourcecode (#171 @esc)
- Changes from 0.8.0 to 0.8.1
- ===========================
- - Downgrade to Blosc v1.4.1 (#144 @esc)
- - Fix license include (#143 @esc)
- - Upgrade to Cython 0.22 (#145 @esc)
- Changes from 0.7.3 to 0.8.0
- ===========================
- - Public API for ``carray`` (#98 @FrancescElies and #esc)
- A Cython definition file ``carrat_ext.pxd`` was added that contains the
- definitions for the ``carray``, ``chunks`` and ``chunk`` classes. This was
- done to allow more complex programs to be built on the compressed container
- primitives provided by bcolz.
- - Overhaul the release procedure
- - Other miscellaneous fixes and improvements
- Changes from 0.7.2 to 0.7.3
- ===========================
- - Update to Blosc ``v1.5.2``
- - Added support for pickling persistent carray/ctable objects. Basically,
- what is serialized is the ``rootdir`` so the data is still sitting on disk
- and the original contents in ``rootdir`` are still needed for unpickling.
- (#79 @mrocklin)
- - Fixed repr-ing of ``datetime64`` ``carray`` objects (#99 @cpcloud)
- - Fixed Unicode handling for column addressing (#91 @CarstVaartjes)
- - Conda recipe and ``.binstar.yml`` (#88 @mrocklin and @cpcloud)
- - Removed ``unittest2`` as a run-time dependency (#90 @mrocklin)
- - Various typo fixes. (#75 @talumbau, #86 @catawbasam and #83 @bgrant)
- - Other miscellaneous fixes and improvements
- Changes from 0.7.1 to 0.7.2
- ===========================
- - Fix various test that were failing on 32 bit, especially a segfault
- - Fix compatibility with Numpy 1.9
- - Fix compatibility with Cython 0.21.
- - Allow tests to be executed with ``nosetests``.
- - Include git hash in version info when applicable.
- - Initial support for testing on Travis CI.
- - Close file handle when ``nodepath`` arg to ``ctable.fromhdf5`` is incorrect.
- - Introduced a new ``carray.view()`` method returning a light-weight
- carray object describing the same data than the original carray. This
- is mostly useful for iterators, but other uses could be devised as
- well.
- - Each iterator now return a view (see above) of the original object, so
- things like::
- >>> bc = bcolz.ctable([[1, 2, 3], [10, 20, 30]], names=['a', 'b'])
- >>> bc.where('a >= 2') # call .where but don't do anything with it
- <itertools.imap at 0x7fd7a84f5750>
- >>> list(bc['b']) # later iterate over table, get where result
- [10, 20, 30]
- works as expected now.
- - Added a workaround for dealing with Unicode types.
- - Fix writing absolute paths into the persistent metadata.
- - ``next(carray)`` calls now work as they should.
- - Fix the ``__repr__`` method of the ``chunk`` class.
- - Prevent sometimes incorrect assignment of dtype to name with fromhdf5.
- - Various miscellaneous bug-fixes, pep8 improvements and typo-fixes.
- Changes from 0.7.0 to 0.7.1
- ===========================
- - Return the outcome of the test for checking that in standalone
- programs. Thanks to Ilan Schnell for suggesting that.
- - Avoiding importing lists of ints as this has roundtrip problems in
- 32-bit platforms.
- - Got rid of the nose dependency for Python 2.6. Thanks to Ilan Schnell
- for the suggestion.
- Changes from 0.5.1 to 0.7.0
- ===========================
- - Renamed the ``carray`` package to ``bcolz``.
- - Added support for Python 3.
- - Added a new function `iterblocks` for quickly returning blocks of
- data, not just single elements. ctable receives a new `whereblocks`
- method, which is the equivalent of `where` but returning data blocks.
- - New pandas import/export functionality via `ctable.fromdataframe()`
- and `ctable.todataframe()`.
- - New HDF5/PyTables import/export functionality via `ctable.fromhdf5()`
- and `ctable.tohdf5()`.
- - Support for c-blosc 1.4.1. This allows the use of different
- compressors via the new `cname` parameter in the `cparams` class, and
- also to be used in platforms not supporting unaligned access.
- - Objects are supported in carray containers (not yet for ctable).
- - Added a new `free_cachemem()` method for freeing internal caches after
- reading/querying carray/ctable objects.
- - New `cparams.setdefaults()` method for globally setting defaults in
- compression parameters during carray/ctable creation.
- - Disabled multi-threading in both Blosc and numexpr because it is not
- delivering the promised speedups yet. This can always be re-activated
- by using `blosc_set_nthreads(nthreads)` and
- `numexpr.set_num_threads(nthreads)`.
- Changes from 0.5 to 0.5.1
- =========================
- - Added the missing bcolz.tests module in setup.py.
- Changes from 0.4 to 0.5
- =======================
- - Introduced support for persistent objects. Now, every carray and
- ctable constructor support a new `rootdir` parameter where you can
- specify the path where you want to make the data stored.
- The format chosen is explained in the 'persistence.rst' file, except
- that the blockpack format is still version 1 (that will probably
- change in future versions). Also, JSON is used for storing metadata
- instead of YAML. This is mainly for avoiding a new library
- dependency.
- - New `open(rootdir, mode='a')` top level function so as to open on-disk
- bcolz objects.
- - New `flush()` method for `carray` and `ctable` objects. This is
- useful for flushing data to disk in persistent objects.
- - New `walk(dir, classname=None, mode='a')` top level function for
- listing carray/ctable objects handing from `dir`.
- - New `attrs` accessor is provided, so that users can store
- its own metadata (in a persistent way, if desired).
- - Representation of carray/ctable objects is based now on the same code
- than NumPy.
- - Reductions (`sum` and `prod`) work now, even with the `axis` parameter
- (when using the Numexpr virtual machine).
- Changes from 0.3.2 to 0.4
- =========================
- - Implemented a `skip` parameter for iterators in `carray` and `ctable`
- objects. This complements `limit` for selecting the number of
- elements to be returned by the iterator.
- - Implemented multidimensional indexing for carrays. Than means that
- you can do::
- >>> a = ca.zeros((2,3))
- Now, you can access any element in any dimension::
- >>> a[1]
- array([ 0., 0., 0.])
- >>> a[1,::2]
- array([ 0., 0.])
- >>> a[1,1]
- 0.0
- - `dtype` and `shape` attributes follow now ndarray (NumPy) convention.
- The `dtype` is always a scalar and the dimensionality is added to the
- `shape` attribute. Before, all the additional dimensionality was in
- the `dtype`. The new convention should be more familiar for
- everybody.
- Changes from 0.3.1 to 0.3.2
- ===========================
- - New `vm` parameter for `eval()` that allows to choose a 'python' or
- 'numexpr' virtual machine during operations. If numexpr is not
- detected, the default will be 'python'.
- That means that you can use any function available in Python for
- evaluating bcolz expressions and that numexpr is not necessary
- anymore for using `eval()`.
- - New `out_flavor` parameter for `eval()` that allows to choose the
- output type. It can be 'bcolz' or 'numpy'.
- - New `defaults.py` module that enables the user to modify the defaults
- for internal bcolz operation. Defaults that are currently
- implemented: `eval_out_flavor` and `eval_vm`.
- - Fixed a bug with `carray.sum()` for multidimensional types.
- Changes from 0.3 to 0.3.1
- =========================
- - Added a `limit` parameter to `iter`, `where` and `wheretrue` iterators
- of carray object and to `iter` and `where` of ctable object.
- - Full support for multidimensional carrays. All types are supported,
- except the 'object' type (that applies to unidimensional carrays too).
- - Added a new `reshape()` for reshaping to new (multidimensional)
- carrays. This supports the same functionality than `reshape()` in
- NumPy.
- - The behaviour of a carray was altered after using an iterator. This
- has been fixed. Thanks to Han Genuit for reporting.
- Changes from 0.2 to 0.3
- =======================
- - Added a new `ctable` class that implements a compressed, column-wise
- table.
- - New `arange()` constructor for quickly building carray objects (this
- method is much faster than using `fromiter()`).
- - New `zeros()` constructor for quickly building zeroed carray objects.
- This is way faster than its NumPy counterpart.
- - New `ones()` constructor for quickly building 1's carray objects.
- Very fast.
- - New `fill()` constructor for quickly building carray objects with a
- filling value. This is very fast too.
- - New `trim()` method for `carray` and `ctable` objects for trimming
- items.
- - New `resize()` method for `carray` and `ctable` objects for resizing
- lengths.
- - New `test()` function that runs the complete test suite.
- - Added a new `eval()` function to evaluate expressions including any
- combination of carrays, ndarrays, sequences or scalars. Requires
- Numexpr being installed.
- - Added new `__len__()` and `__sizeof__()` special methods for both
- `carray` and `ctable` objects.
- - New `sum()` method for `carray` that computes the sum of the array
- elements.
- - Added new `nbytes` and `cbytes` properties for `carray` and `ctable`
- objects. The former accounts for the size of the original
- (non-compressed) object, and the later for the actual compressed
- object.
- - New algorithm for computing an optimal chunk size for carrays based on
- the new `expectedlen` argument.
- - Added `chunklen` property for `carray` that allows querying the chunk
- length (in rows) for the internal I/O buffer.
- - Added a new `append(rows)` method to `ctable` class.
- - Added a new `wheretrue()` iterator for `carray` that returns the
- indices for true values (only valid for boolean arrays).
- - Added a new `where(boolarr)` iterator for `carray` that returns the
- values where `boolarr` is true.
- - New idiom ``carray[boolarr]`` that returns the values where `boolarr`
- is true.
- - New idiom ``ctable[boolarr]`` that returns the rows where `boolarr` is
- true.
- - Added a new `eval()` method for `ctable` that is able to evaluate
- expressions with columns. It needs numexpr to be installed.
- - New idiom ``ctable[boolexpr]`` that returns the rows fulfilling the
- boolean expression. Needs numexpr.
- - Added fancy indexing (as a list of integers) support to `carray` and
- `ctable`.
- - Added `copy(clevel, shuffle)` method to both `carray` and `ctable`
- objects.
- - Removed the `toarray()` method in `carray` as this was equivalent to
- ``carray[:]`` idiom.
- - Renamed `setBloscMaxThreads()` to `blosc_set_num_threads()` and
- `whichLibVersion()` to `blosc_version()` to follow bcolz name
- conventions more closely.
- - Added a new `set_num_threads()` to set the number of threads in both
- Blosc and Numexpr (if available).
- - New `fromiter()` constructor for creating `carray` objects from
- iterators. It follows the NumPy API convention.
- - New `cparams(clevel=5, shuffle=True)` class to host all params related
- with compression.
- - Added more indexing support for `carray.__getitem__()`. All indexing
- modes present in NumPy are supported now, including fancy indexing.
- The only exception are negative steps in ``carray[start:stop:-step]``.
- - Added support for `bcolz.__setitem__()`. All indexing modes present
- in NumPy are supported, including fancy indexing. The only exception
- are negative steps in ``carray[start:stop:-step] = values``.
- - Added support for `ctable.__setitem__()`. All indexing modes present
- in NumPy are supported, including fancy indexing. The only exception
- are negative steps in ``ctable[start:stop:-step] = values``.
- - Added new `ctable.__iter__()`, `ctable.iter()` and `ctable.where()`
- iterators mimicking the functionality in carray object.
- Changes from 0.1 to 0.2
- =======================
- - Added a couple of iterators for carray: `__iter__()` and `iter(start,
- stop, step)`. The difference is that the later does accept slices.
- - Added a `__len__()` method.
- .. Local Variables:
- .. mode: rst
- .. coding: utf-8
- .. fill-column: 72
- .. End:
|