def _roperation(self, func, other):
return _operation.operation(func,
other,
self,
broadcast=get_option('op.broadcast'),
reindex=get_option('op.reindex'),
constructor=self._constructor)
def _setitem(self, indices, values, axis=0, indexing=None, tol=None, broadcast=None, cast=False, inplace=True):
"""
See Also
--------
DimArray.read, DimArrayOnDisk.write
"""
if broadcast is None:
if self._broadcast is None:
broadcast = get_option('indexing.broadcast')
else:
broadcast = self._broadcast
if not inplace:
self = self.copy()
# special-case: full-shape boolean indexing (will fail with netCDF4)
if self._is_boolean_index_nd(indices):
self._setvalues_bool(indices, values, cast=cast)
else:
idx = self._get_indices(indices, tol=tol, indexing=indexing, axis=axis)
if broadcast:
self._setvalues_broadcast(idx, values, cast=cast)
else:
self._setvalues_ortho(idx, values, cast=cast)
if not inplace:
return self
def repr_dimarray(self, metadata=False, lazy=False):
header = self.__class__.__name__
# lazy = not isinstance(self, da.DimArray))
if lazy:
header = header + ": " + repr(self.name) + " (%i" % self.size + ")"
else:
header = self.__class__.__name__.lower() + ": " + stats_dimarray(self)
lines = [header]
# axes
if self.ndim > 0:
lines.append(repr_axes(self.axes, metadata=metadata))
# metadata
if metadata and len(self.attrs) > 0:
lines.append("attributes:")
lines.append(repr_attrs(self.attrs))
# lines.append(str_attrs(self.attrs, indent=8) )
# the data itself
if lazy:
# line = "array(...)" if self.ndim > 0 else str(self[0])
# line = self.name+("(...)" if self.ndim > 0 else repr((self[0],)))
line = ""
elif self.size > get_option("display.max"):
line = "array(...)"
else:
line = repr(self.values)
if line:
lines.append(line)
return "\n".join(lines)
def _maybe_open_file(f, mode="r", clobber=None, verbose=False, format=None):
""" open a netCDF4 file
Parameters
----------
f : file name (str) or netCDF file handle
mode: changed from original 'r','w','r' & clobber option:
mode : `str`
read or write access
- 'r': read
- 'w' : write, overwrite if file if present (clobber=True)
- 'w-': create new file, but raise Exception if file is present (clobber=False)
- 'a' : append, raise Exception if file is not present
- 'a+': append if file is present, otherwise create
format: passed to netCDF4.Dataset, only relevatn when mode = 'w', 'w-', 'a+'
'NETCDF4', 'NETCDF4_CLASSIC', 'NETCDF3_CLASSIC', 'NETCDF3_64BIT'
Returns
-------
f : netCDF file handle
close: `bool`, `True` if input f indicated file name
"""
format = format or get_option("io.nc.format")
if mode == "w-":
mode = "w"
if clobber is None:
clobber = False
# mode 'a+' appends if file exists, otherwise create new variable
elif mode == "a+" and not isinstance(f, nc.Dataset):
if os.path.exists(f):
mode = "a"
else:
mode = "w"
if clobber is None:
clobber = False
else:
if clobber is None:
clobber = True
if not isinstance(f, nc.Dataset):
fname = f
# make sure the file does not exist if mode == "w"
if os.path.exists(fname) and clobber and mode == "w":
os.remove(fname)
try:
f = nc.Dataset(fname, mode, clobber=clobber, format=format)
except UserWarning, msg:
print msg
except Exception, msg: # raise a weird RuntimeError
# print "read from",fname
raise IOError("{} => failed to opend {} in mode {}".format(msg, fname, mode)) # easier to handle
def take_axis(self, indices, axis=0, indexing=None, mode='raise'):
""" Analogous to DimArray.take_axis
"""
if not np.iterable(indices):
raise TypeError("indices must be iterable")
indexing = indexing or getattr(self, "_indexing", None) or get_option("indexing.by")
if indexing == "label":
indices = self.axes[axis].loc(indices, mode=mode)
if mode not in ('raise', 'clip', 'wrap'):
mode = 'raise'
return self.reduce_axis(np.take, indices=indices, axis=axis, mode=mode, keepattrs=True, keepdims=True)
def _binary_op(self, func, other):
""" generalize DimArray operation to a Dataset, for each key
In case the keys differ, returns the intersection of the two datasets
Just for testing:
>>> ds = Dataset(b=DimArray([[0.,1],[1,2]]))
>>> -ds
Dataset of 1 variable
0 / x0 (2): 0 to 1
1 / x1 (2): 0 to 1
b: ('x0', 'x1')
>>> -ds["b"]
dimarray: 4 non-null elements (0 null)
0 / x0 (2): 0 to 1
1 / x1 (2): 0 to 1
array([[-0., -1.],
[-1., -2.]])
>>> np.all(ds == ds)
True
>>> assert isinstance(-ds, Dataset)
>>> assert isinstance(ds/0.5, Dataset)
>>> assert isinstance(ds*0, Dataset)
>>> (-ds -ds + ds/0.5 + ds*0+1)['b']
dimarray: 4 non-null elements (0 null)
0 / x0 (2): 0 to 1
1 / x1 (2): 0 to 1
array([[1., 1.],
[1., 1.]])
>>> ds += 1
>>> ds['b']
dimarray: 4 non-null elements (0 null)
0 / x0 (2): 0 to 1
1 / x1 (2): 0 to 1
array([[1., 2.],
[2., 3.]])
"""
assert isinstance(other, Dataset) or isscalar(other), "can only combine Datasets objects (func={})".format(func.__name__)
# align all axes first
reindex = get_option("op.reindex")
if reindex and hasattr(other, 'axes') and other.axes != self.axes:
other.reindex_like(self)
# now proceed to operation
res = self.__class__()
for k1 in self.keys():
if hasattr(other, 'keys'):
for k2 in other.keys():
if k1 == k2:
res[k1] = self[k1]._binary_op(func, other[k2])
else:
res[k1] = self[k1]._binary_op(func, other)
return res
def _getitem(self, indices=None, axis=0, indexing=None, tol=None, broadcast=None, keepdims=False,
broadcast_arrays=None, # back-compatibility for broadcast
):
if indices is None:
indices = ()
if broadcast_arrays is not None:
warnings.warn(FutureWarning("broadcast_arrays is deprecated, use broadcast instead"))
broadcast = broadcast_arrays
if broadcast is None:
if self._broadcast is None:
broadcast = get_option('indexing.broadcast')
else:
broadcast = self._broadcast
# special-case: full-shape boolean indexing (will fail with netCDF4)
if self._is_boolean_index_nd(indices):
if hasattr(self, 'compress'):
return self.compress(indices)
else:
raise TypeError("{} does not support boolean indexing".format(self.__class__.__name__))
idx = self._get_indices(indices, axis=axis, indexing=indexing, tol=tol, keepdims=keepdims)
# special case: broadcast arrays a la numpy
if broadcast:
axes = self._getaxes_broadcast(idx)
values = self._getvalues_broadcast(idx)
else:
axes = self._getaxes_ortho(idx)
values = self._getvalues_ortho(idx)
if np.isscalar(values):
return values
dima = self._constructor(values, axes) # initialize DimArray
dima.attrs.update(self.attrs) # add attribute
return dima
def __repr__(self):
""" pretty printing
"""
try:
if self.ndim > 0:
nonnull = np.size(self.values[~np.isnan(self.values)])
else:
nonnull = ~np.isnan(self.values)
except TypeError: # e.g. object
nonnull = self.size
lines = []
#if self.size < 10:
# line = "dimarray: "+repr(self.values)
#else:
line = "dimarray: {} non-null elements ({} null)".format(
nonnull, self.size - nonnull)
lines.append(line)
# # show metadata as well?
# If len(self.ncattrs()) > 0:
# line = self.repr_meta()
# lines.append(line)
if True: #self.size > 1:
line = repr(self.axes)
lines.append(line)
if self.size < get_option('display.max'):
line = repr(self.values)
else:
line = "array(...)"
lines.append(line)
return "\n".join(lines)
def __repr__(self):
""" pretty printing
"""
try:
if self.ndim > 0:
nonnull = np.size(self.values[~np.isnan(self.values)])
else:
nonnull = ~np.isnan(self.values)
except TypeError: # e.g. object
nonnull = self.size
lines = []
#if self.size < 10:
# line = "dimarray: "+repr(self.values)
#else:
line = "dimarray: {} non-null elements ({} null)".format(nonnull, self.size-nonnull)
lines.append(line)
# # show metadata as well?
# If len(self.ncattrs()) > 0:
# line = self.repr_meta()
# lines.append(line)
if True: #self.size > 1:
line = repr(self.axes)
lines.append(line)
if self.size < get_option('display.max'):
line = repr(self.values)
else:
line = "array(...)"
lines.append(line)
return "\n".join(lines)
from dimarray.core import DimArray, Axis, Axes
from dimarray.config import get_option
from dimarray.core.bases import AbstractDimArray, AbstractDataset, AbstractAxis, GetSetDelAttrMixin, AbstractAxes
# from dimarray.core.metadata import _repr_metadata
from dimarray.prettyprinting import repr_axis, repr_axes, repr_dimarray, repr_dataset, repr_attrs
from .conventions import encode_cf_datetime, decode_cf_datetime
__all__ = ["read_nc", "summary_nc", "write_nc"]
#
# Global variables
#
FORMAT = get_option("io.nc.format") # for the doc
#
# Helper functions
#
def maybe_encode_values(values, format=None):
""" strings are given "object" type in Axis object
==> assume all objects are actually strings
NOTE: this will fail for other object-typed axes such as tuples
"""
# if dtype is np.dtype('O'):
values = np.asarray(values)
dtype = values.dtype
cf_attrs = {}
if dtype.kind in ("S", "O"):
def reindex_axis(self, values, axis=0, method="exact", repna=True, fill_value=np.nan, tol=TOLERANCE, use_pandas=None):
""" reindex an array along an axis
Input:
- values : array-like or Axis: new axis values
- axis : axis number or name
- method : "exact" (default), "nearest", "interp"
- repna: if False, raise error when an axis value is not present
otherwise just replace with NaN. Defaulf is True
- fill_value: value to use instead of missing data
- tol: re-index with a particular tolerance (can be longer)
- use_pandas, optional: bool : if True (the default), convert to pandas for re-indexing
If any special option (method, tol) is set or if modulo axes are present
or, of course, if pandas is not installed,
this option is set to False by default.
Output:
- DimArray
Examples:
---------
Basic reindexing: fill missing values with NaN
>>> a = da.DimArray([1,2,3],('x0', [1,2,3]))
>>> b = da.DimArray([3,4],('x0',[1,3]))
>>> b.reindex_axis([1,2,3])
dimarray: 2 non-null elements (1 null)
dimensions: 'x0'
0 / x0 (3): 1 to 3
array([ 3., nan, 4.])
Or replace with anything else, like -9999
>>> b.reindex_axis([1,2,3], fill_value=-9999)
dimarray: 3 non-null elements (0 null)
dimensions: 'x0'
0 / x0 (3): 1 to 3
array([ 3, -9999, 4])
"nearest" mode
>>> b.reindex_axis([0,1,2,3], method='nearest') # out-of-bound to NaN
dimarray: 3 non-null elements (1 null)
dimensions: 'x0'
0 / x0 (4): 0 to 3
array([ nan, 3., 3., 4.])
"interp" mode
>>> b.reindex_axis([0,1,2,3], method='interp') # out-of-bound to NaN
dimarray: 3 non-null elements (1 null)
dimensions: 'x0'
0 / x0 (4): 0 to 3
array([ nan, 3. , 3.5, 4. ])
"""
if isinstance(values, Axis):
newaxis = values
values = newaxis.values
axis = newaxis.name
axis_id = self.axes.get_idx(axis)
ax = self.axes[axis_id] # Axis object
axis_nm = ax.name
# do nothing if axis is same or only None element
if ax.values[0] is None or np.all(values == ax.values):
return self
# check whether pandas can be used for re-indexing
if use_pandas is None:
use_pandas = get_option("optim.use_pandas")
# ...any special option activated?
if (
method != "exact" or tol is not None or ax.tol is not None or ax.modulo is not None or self.ndim > 4
): # pandas defined up to 4-D
use_pandas = False
# ...is pandas installed?
try:
import pandas
except ImportError:
use_pandas = False
# re-index using pandas
if use_pandas:
pandasobj = self.to_pandas()
newpandas = pandasobj.reindex_axis(values, axis=axis_id, fill_value=fill_value)
newobj = self.from_pandas(newpandas) # use class method from_pandas
newobj._metadata = self._metadata # add metadata back
newobj.axes[axis_id].name = axis_nm # give back original name
# indices along which to sample
elif method == "exact":
newobj = take_na(self, values, axis=axis, repna=repna, fill_value=fill_value)
elif method in ("nearest", "interp"):
from interpolation import interp
newobj = interp(self, values, axis=axis, method=method, repna=repna)
else:
raise ValueError("invalid reindex_axis method: " + repr(method))
# assert np.all((np.isnan(ax0.values) | (ax0.values == ax1.values))), "pb when reindexing"
return newobj
def _operation(self, func, other):
""" make an operation: this include axis and dimensions alignment
Just for testing:
>>> b = DimArray([[0.,1],[1,2]])
>>> b
... # doctest: +SKIP
array([[ 0., 1.],
[ 1., 2.]])
>>> np.all(b == b)
True
>>> np.all(b+2 == b + np.ones(b.shape)*2)
True
>>> np.all(b+b == b*2)
True
>>> np.all(b*b == b**2)
True
>>> np.all((b - b.values) == b - b)
True
>>> -b
dimarray: 4 non-null elements (0 null)
dimensions: 'x0', 'x1'
0 / x0 (2): 0 to 1
1 / x1 (2): 0 to 1
array([[-0., -1.],
[-1., -2.]])
>>> np.all(-b == 0. - b)
True
True divide by default
>>> a = DimArray([1,2,3])
>>> a/2
dimarray: 3 non-null elements (0 null)
dimensions: 'x0'
0 / x0 (3): 0 to 2
array([ 0.5, 1. , 1.5])
>>> a//2
dimarray: 3 non-null elements (0 null)
dimensions: 'x0'
0 / x0 (3): 0 to 2
array([0, 1, 1])
Test group/corps structure (result of operation remains DimArray)
>>> a = DimArray([[1.,2,3],[4,5,6]])
>>> isinstance(a + 2., DimArray)
True
>>> isinstance(2. + a, DimArray)
True
>>> isinstance(2 * a, DimArray)
True
>>> isinstance(a * 2, DimArray)
True
>>> isinstance(2 / a, DimArray)
True
>>> isinstance(a / 2, DimArray)
True
>>> isinstance(2 - a, DimArray)
True
>>> isinstance(a - 2, DimArray)
True
>>> s = 0.
>>> for i in range(5):
... s = s + a
>>> isinstance(a, DimArray)
True
>>> np.all(s == 5*a)
True
"""
result = _operation.operation(func,
self,
other,
broadcast=get_option('op.broadcast'),
reindex=get_option('op.reindex'),
constructor=self._constructor)
return result
def _get_indices(self, indices, axis=0, indexing=None, tol=None, keepdims=False):
""" Return an n-D indexer
Parameters
----------
**kwargs: same as DimArray.take or DimArrayOnDisk.read
Returns
-------
indexer : tuple of numpy-compatible indices, of length equal to the number of
dimensions.
"""
indexing = indexing or getattr(self,'_indexing',None) or get_option('indexing.by')
dims = self.dims
if indices is None:
indices = ()
if tol is None:
tol = getattr(self, '_tol', None)
#
# Convert indices to tuple, from a variety of input formats
#
# special case: numpy like (idx, axis)
if axis not in (0, None):
indices = {axis:indices}
# special case: Axes is provided as index
elif isinstance(indices, AbstractAxes):
indices = {ax.name:ax.values for ax in indices}
# should always be a tuple
if isinstance(indices, dict):
# replace int dimensions with str dimensions
for k in indices:
if not isinstance(k, basestring):
indices[dims[k]] = indices[k]
del indices[k]
else:
if k not in dims:
raise ValueError("Dimension {} not found. Existing dimensions: {}".format(k, dims))
indices = tuple(indices[d] if d in indices else slice(None) for d in dims)
# expand to N-D tuple, and expands ellipsis
indices = expanded_indexer(indices, self.ndim)
# load each dimension as necessary
indexer = ()
for i, ix in enumerate(indices):
dim = dims[i]
if not np.isscalar(ix) and not isinstance(ix, slice):
ix = np.asarray(ix)
# boolean indices are fine
if isinstance(ix, np.ndarray) and ix.dtype.kind == 'b':
pass
# in case of label-based indexing, need to read the whole dimension
# and look for the appropriate values
elif indexing != 'position' and not (type(ix) is slice and ix == slice(None)):
# find the index corresponding to the required axis value
lix = ix
ix = self.axes[dim].loc(lix, tol=tol)
# numpy rule: a singleton list does not collapse the axis
if keepdims and np.isscalar(ix):
ix = [ix]
indexer += (ix,)
return indexer
def __init__(self,
values=None,
axes=None,
dims=None,
labels=None,
copy=False,
dtype=None,
_indexing=None,
_indexing_broadcast=None,
**kwargs):
""" Initialization. See help on DimArray.
"""
# check if attached to values (e.g. DimArray object)
if hasattr(values, "axes") and axes is None:
axes = values.axes
# default options
if _indexing is None: _indexing = get_option('indexing.by')
if _indexing_broadcast is None:
_indexing_broadcast = get_option('indexing.broadcast')
#
# array values
#
# if masked array, replace mask by NaN
if isinstance(values, np.ma.MaskedArray):
try:
values = values.filled(np.nan) # fill mask with nans
# first convert to float
except:
values = np.ma.asarray(values, dtype=float).filled(
np.nan) # fill mask with nans
if values is not None:
values = np.array(values, copy=copy, dtype=dtype)
#
# Initialize the axes
#
if axes is None and labels is None:
assert values is not None, "values= or/and axes=, labels= required to determine dimensions"
axes = Axes._init(axes,
dims=dims,
labels=labels,
shape=values.shape if values is not None else None)
assert type(axes) is Axes
# if values not provided, create empty data, filled with NaNs if dtype is float
if values is None:
values = np.empty([ax.size for ax in axes], dtype=dtype)
if dtype in (float, None, np.dtype(float)):
values.fill(np.nan)
else:
warnings.warn(
"no nan representation for {}, array left empty".format(
repr(dtype)))
#
# store all fields
#
self.values = values
self.axes = axes
## options
self._indexing = _indexing
self._indexing_broadcast = _indexing_broadcast
#
# metadata (see Metadata type in metadata.py)
#
#for k in kwargs:
# setncattr(self, k, kwargs[k]) # perform type-checking and store in self._metadata
self._metadata = kwargs
# Check consistency between axes and values
inferred = tuple([ax.size for ax in self.axes])
if inferred != self.values.shape:
msg = """\
shape inferred from axes: {}
shape inferred from data: {}
mismatch between values and axes""".format(inferred, self.values.shape)
raise Exception(msg)
# If a general ordering relationship of the class is assumed,
# always sort the class
if self._order is not None and self.dims != tuple(
dim for dim in self._order if dim in self.dims):
present = filter(lambda x: x in self.dims,
self._order) # prescribed
missing = filter(lambda x: x not in self._order, self.dims) # not
order = missing + present # prepend dimensions not found in ordering relationship
obj = self.transpose(order)
self.values = obj.values
self.axes = obj.axes
from dimarray.dataset import Dataset, concatenate_ds, stack_ds
from dimarray.core import DimArray, Axis, Axes
from dimarray.config import get_option
from dimarray.core.bases import AbstractDimArray, AbstractDataset, AbstractAxis, GetSetDelAttrMixin, AbstractAxes
# from dimarray.core.metadata import _repr_metadata
from dimarray.prettyprinting import repr_axis, repr_axes, repr_dimarray, repr_dataset, repr_attrs
from .conventions import encode_cf_datetime, decode_cf_datetime
__all__ = ['read_nc','summary_nc', 'write_nc']
#
# Global variables
#
FORMAT = get_option('io.nc.format') # for the doc
#
# Helper functions
#
def maybe_encode_values(values, format=None):
""" strings are given "object" type in Axis object
==> assume all objects are actually strings
NOTE: this will fail for other object-typed axes such as tuples
"""
# if dtype is np.dtype('O'):
values = np.asarray(values)
dtype = values.dtype
cf_attrs = {}
if dtype.kind in ('S','O'):
def __init__(self, values=None, axes=None, dims=None, labels=None, copy=False, dtype=None, _indexing=None, _indexing_broadcast=None, **kwargs):
""" Initialization. See help on DimArray.
"""
# check if attached to values (e.g. DimArray object)
if hasattr(values, "axes") and axes is None:
axes = values.axes
# default options
if _indexing is None: _indexing = get_option('indexing.by')
if _indexing_broadcast is None: _indexing_broadcast = get_option('indexing.broadcast')
#
# array values
#
# if masked array, replace mask by NaN
if isinstance(values, np.ma.MaskedArray):
try:
values = values.filled(np.nan) # fill mask with nans
# first convert to float
except:
values = np.ma.asarray(values, dtype=float).filled(np.nan) # fill mask with nans
if values is not None:
values = np.array(values, copy=copy, dtype=dtype)
#
# Initialize the axes
#
if axes is None and labels is None:
assert values is not None, "values= or/and axes=, labels= required to determine dimensions"
axes = Axes._init(axes, dims=dims, labels=labels, shape=values.shape if values is not None else None)
assert type(axes) is Axes
# if values not provided, create empty data, filled with NaNs if dtype is float
if values is None:
values = np.empty([ax.size for ax in axes], dtype=dtype)
if dtype in (float, None, np.dtype(float)):
values.fill(np.nan)
else:
warnings.warn("no nan representation for {}, array left empty".format(repr(dtype)))
#
# store all fields
#
self.values = values
self.axes = axes
## options
self._indexing = _indexing
self._indexing_broadcast = _indexing_broadcast
#
# metadata (see Metadata type in metadata.py)
#
#for k in kwargs:
# setncattr(self, k, kwargs[k]) # perform type-checking and store in self._metadata
self._metadata = kwargs
# Check consistency between axes and values
inferred = tuple([ax.size for ax in self.axes])
if inferred != self.values.shape:
msg = """\
shape inferred from axes: {}
shape inferred from data: {}
mismatch between values and axes""".format(inferred, self.values.shape)
raise Exception(msg)
# If a general ordering relationship of the class is assumed,
# always sort the class
if self._order is not None and self.dims != tuple(dim for dim in self._order if dim in self.dims):
present = filter(lambda x: x in self.dims, self._order) # prescribed
missing = filter(lambda x: x not in self._order, self.dims) # not
order = missing + present # prepend dimensions not found in ordering relationship
obj = self.transpose(order)
self.values = obj.values
self.axes = obj.axes
def _roperation(self, func, other):
return _operation.operation(func, other, self, broadcast=get_option('op.broadcast'), reindex=get_option('op.reindex'), constructor=self._constructor)
def _operation(self, func, other):
""" make an operation: this include axis and dimensions alignment
Just for testing:
>>> b = DimArray([[0.,1],[1,2]])
>>> b
... # doctest: +SKIP
array([[ 0., 1.],
[ 1., 2.]])
>>> np.all(b == b)
True
>>> np.all(b+2 == b + np.ones(b.shape)*2)
True
>>> np.all(b+b == b*2)
True
>>> np.all(b*b == b**2)
True
>>> np.all((b - b.values) == b - b)
True
>>> -b
dimarray: 4 non-null elements (0 null)
dimensions: 'x0', 'x1'
0 / x0 (2): 0 to 1
1 / x1 (2): 0 to 1
array([[-0., -1.],
[-1., -2.]])
>>> np.all(-b == 0. - b)
True
True divide by default
>>> a = DimArray([1,2,3])
>>> a/2
dimarray: 3 non-null elements (0 null)
dimensions: 'x0'
0 / x0 (3): 0 to 2
array([ 0.5, 1. , 1.5])
>>> a//2
dimarray: 3 non-null elements (0 null)
dimensions: 'x0'
0 / x0 (3): 0 to 2
array([0, 1, 1])
Test group/corps structure (result of operation remains DimArray)
>>> a = DimArray([[1.,2,3],[4,5,6]])
>>> isinstance(a + 2., DimArray)
True
>>> isinstance(2. + a, DimArray)
True
>>> isinstance(2 * a, DimArray)
True
>>> isinstance(a * 2, DimArray)
True
>>> isinstance(2 / a, DimArray)
True
>>> isinstance(a / 2, DimArray)
True
>>> isinstance(2 - a, DimArray)
True
>>> isinstance(a - 2, DimArray)
True
>>> s = 0.
>>> for i in range(5):
... s = s + a
>>> isinstance(a, DimArray)
True
>>> np.all(s == 5*a)
True
"""
result = _operation.operation(func, self, other, broadcast=get_option('op.broadcast'), reindex=get_option('op.reindex'), constructor=self._constructor)
return result
def __init__(self, ds, name, _indexing=None):
self._indexing = _indexing or get_option('indexing.by')
self._ds = ds
self._name = name
def reindex_axis(self,
values,
axis=0,
method='exact',
repna=True,
fill_value=np.nan,
tol=TOLERANCE,
use_pandas=None):
""" reindex an array along an axis
Input:
- values : array-like or Axis: new axis values
- axis : axis number or name
- method : "exact" (default), "nearest", "interp"
- repna: if False, raise error when an axis value is not present
otherwise just replace with NaN. Defaulf is True
- fill_value: value to use instead of missing data
- tol: re-index with a particular tolerance (can be longer)
- use_pandas, optional: bool : if True (the default), convert to pandas for re-indexing
If any special option (method, tol) is set or if modulo axes are present
or, of course, if pandas is not installed,
this option is set to False by default.
Output:
- DimArray
Examples:
---------
Basic reindexing: fill missing values with NaN
>>> a = da.DimArray([1,2,3],('x0', [1,2,3]))
>>> b = da.DimArray([3,4],('x0',[1,3]))
>>> b.reindex_axis([1,2,3])
dimarray: 2 non-null elements (1 null)
dimensions: 'x0'
0 / x0 (3): 1 to 3
array([ 3., nan, 4.])
Or replace with anything else, like -9999
>>> b.reindex_axis([1,2,3], fill_value=-9999)
dimarray: 3 non-null elements (0 null)
dimensions: 'x0'
0 / x0 (3): 1 to 3
array([ 3, -9999, 4])
"nearest" mode
>>> b.reindex_axis([0,1,2,3], method='nearest') # out-of-bound to NaN
dimarray: 3 non-null elements (1 null)
dimensions: 'x0'
0 / x0 (4): 0 to 3
array([ nan, 3., 3., 4.])
"interp" mode
>>> b.reindex_axis([0,1,2,3], method='interp') # out-of-bound to NaN
dimarray: 3 non-null elements (1 null)
dimensions: 'x0'
0 / x0 (4): 0 to 3
array([ nan, 3. , 3.5, 4. ])
"""
if isinstance(values, Axis):
newaxis = values
values = newaxis.values
axis = newaxis.name
axis_id = self.axes.get_idx(axis)
ax = self.axes[axis_id] # Axis object
axis_nm = ax.name
# do nothing if axis is same or only None element
if ax.values[0] is None or np.all(values == ax.values):
return self
# check whether pandas can be used for re-indexing
if use_pandas is None:
use_pandas = get_option('optim.use_pandas')
# ...any special option activated?
if method != 'exact' or tol is not None or \
ax.tol is not None or ax.modulo is not None \
or self.ndim > 4: # pandas defined up to 4-D
use_pandas = False
# ...is pandas installed?
try:
import pandas
except ImportError:
use_pandas = False
# re-index using pandas
if use_pandas:
pandasobj = self.to_pandas()
newpandas = pandasobj.reindex_axis(values,
axis=axis_id,
fill_value=fill_value)
newobj = self.from_pandas(newpandas) # use class method from_pandas
newobj._metadata = self._metadata # add metadata back
newobj.axes[axis_id].name = axis_nm # give back original name
# indices along which to sample
elif method == "exact":
newobj = take_na(self,
values,
axis=axis,
repna=repna,
fill_value=fill_value)
elif method in ("nearest", "interp"):
from interpolation import interp
newobj = interp(self, values, axis=axis, method=method, repna=repna)
else:
raise ValueError("invalid reindex_axis method: " + repr(method))
#assert np.all((np.isnan(ax0.values) | (ax0.values == ax1.values))), "pb when reindexing"
return newobj