1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
The maskedarray package went through some major updates recently.
Originally, a MaskedArray object had two major attributes: (i) _data, a
(subclass of) ndarray that stored the values, and (ii) _mask, a ndarray of
booleans storing whether the values were masekd or not. This structure was
directly derived from the original implementation of MaskedArray, available in
numpy.core.ma.
However, this approach wasn't very natural. For example, in order to access the
data of a MaskedArray instance, one had to query the _data attribute instead of
the instance itself. In addition, the previous implementation of MaskedArray as
a subclass of ndarray presented some problems. Thus, most of the attributes of
a MaskedArray object were defined as class defaults, which turned out to be
thread-unsafe. Moreover, subclassing MaskedArray wasn't straightforward, when
the subclass introduced new parameters in its __new__ method.
The current implementation tries to alleviate these problems. The most
significant difference is that the _data attribute is now a view of the array
as a (subclass of) ndarray. The actual type is set by the _baseclass attribute,
defined at the creation of a new masked array as the class of the underlying
data. Thus, it is still possible to use a matrix object as the underlying data:
the new masked array will then use the matrix methods. Note that if the
underlying data has its own attributes, these latter are not propagated to the
MaskedArray instance, but are reinitialized at each access. In other terms, you
will lose specific values of these attributes during processing. You should
then consider defining a subclass of MaskedArray. Note also that because the
_data attribute is a view, any attempt to directly set it will likely fail. For
example, x._data = 5 will raise an AttributeError exception. You should then
use x._data[:] = 5 instead).
The _mask attibute is left unchanged. Because it is a basic attribute, it can
be overwritten far too easily. If you want to specify a new value for the mask,
you should use the _setmask or __setmask__ methods: these methods ensure that
the new mask has the same shape as the data, and that the _hardmask condition
is respected. Note that in some particular cases involving subclasses of
MaskedArray, the mask is not always propagated properly. It is recommended to
set the mask of the base object, instead of trying to set the mask through a
view of MaskedArray.
Following the suggestions of Reggie Dugard, the class defaults have been
suppressed. Unfortunately, that required to add some extra definitions in the
__array_finalize__ method, which tends to have a slight negative impact on
performances. Moreover, most methods now return a view of the masked array
instead of creating a new masked array from scratch.
The previous implementation of MaskedArray is called core_ini.py and it can be
found in the alternative_versions directory. This folder contains also yet
another implementation core_alt. This latter is left for documentation purposes,
and should serve as a template when we'll port the package to C. It introduces
yet another attribute, _masklayer. This attribute is always a ndarray of booleans
with the same shape as the data, that stores the values of the masked. The _mask
attribute is then a property, that returns _masklayer or nomask depending on
the value of the _smallmask flag and the values of _masklayer. This approach
seems to solve the anomaly in mask propagation mentioned earlier. However, some
performance tests show that this approach is significantly slower (from 10% to
50%) than the current implementation. It was therfore decided to leave it out of
the main package.
#...............................................................................
2007-01-22 : core : fixed a call to numpy.float128 on 32b machines
2007-01-21 : core : fixed max/min_fill_values
: : fixed sort (as method and function)
2007-01-18 : core : fixed default filling values for unsigned int_.
2007-01-16 : extras : new function : `mediff1d`
2007-01-15 : mrecords: new method: `addfield`
: core : Force the mask of a masked array `x` to be copied w/...
...masked_array(x,copy=True,mask=nomask,keep_mask=true)
2007-01-14 : mrecords: Slices are now properly supported
: mrecords: `filled` is now properly supported
2007-01-12 : mrecords: Complete reorganization...
2007-01-10 : mrecords: Defines a class of records that support masked arrays
2007-01-08 : Core:
: core : Force a reset of the class defaults after initialization
: core : Modified __array_finallize__ to allow objects w/ _data...
... _mask fields to be recognized as MA
2007-01-04 : core : Fixed a but in masked_all_like
2007-01-02 : extras : Force apply_along_axis to output the proper fill_value
: core : Can use dtypes for the definition of default_fill_value
2006-12-30 : core : Cleaned up setitem/setslice w/ hard_mask=True
: core : Fixed masked_unary/binary_operations...
...to work with subclasses of MaskedArray
2006-12-22 : core : Optimized(?) default_/maximum_/minimum_fill_value
: core : Force __new__ to not return a MaskedArray, in order to ...
: ... optimize __array_finalize__
: core : Add the hard_mask flag to __new__ (*[False]*)
2006-12-19 : core : Fixed a problem on _set_mask which prevented to set a mask to nomask
: extras : Renamed compress2d to compress_rowcols
: extras : Added dot
2006-12-18 : extras : Added compress2d and mask_rowcols
: extras : moved 'average' to 'extras'
2006-12-13 : core : Fixed make_mask (forced filling to True)
: core : Fixed ndim
: core : Fixed error message in __new__ when wrong sizes
: core : Fixed the reshape function.
: extras : masked_all: set default dtype to float_
: extras : _fromnxfunctions: make sure that list are recognized
: extras : added notmasked_edges, notmasked_contiguous
2006-12-09 : - Code reorganization: define 2 modules, core and extras
2006-11-25 : core : Disable copy by default
core : Added keep_mask flag (to save mask when creating a ma from a ma)
core : Fixed functions: empty_like
core : Fixed methods: .any and .all
core : New functions: masked_all, masked_all_like
core : New methods: .squeeze
2006-11-20 : core : fixed make_mask
core : fixed nonzero method
2006-11-16 : core : fixed .T
2006-11-12 : core : add max, min as function (not only method...)
core : repr returns a name like masked_xxx, where xxx is the subclass
2006-10-31 : core : make sure that make_mask returns a pure ndarray.
2006-10-30 : core : When converted to a float, a masked singleton is ...
...transformed to nan instead of raising an exception.
21: Use __get__ method in _arraymethods, _arithmethods, _compamethods
18: Updated put to match the definition of numpy 1.0, deleted putmask, changed resize
2: prevent an extra kword being sent to make_mask_none
#............................................................
|
