def __init__(self,
name=None,
ctype=None,
units=None,
segment_lengths=None,
coord_ref_sys=None):
"""*Do not use.*"""
if name is not None:
self.name = name
if ctype is not None:
self.set_trait('ctype', ctype)
if units is not None:
self.set_trait('units', units)
if coord_ref_sys is not None:
self.set_trait('coord_ref_sys', coord_ref_sys)
if segment_lengths is not None:
if np.array(segment_lengths).ndim == 0:
segment_lengths = make_coord_delta(segment_lengths)
else:
segment_lengths = make_coord_delta_array(segment_lengths)
segment_lengths.setflags(write=False)
self.set_trait('segment_lengths', segment_lengths)
super(Coordinates1d, self).__init__()
def _validate_boundary(self, d):
val = d["value"]
for dim, boundary in val.items():
if dim not in VALID_DIMENSION_NAMES:
raise ValueError("Invalid dimension '%s' in boundary" % dim)
if np.array(boundary).ndim == 0:
try:
delta = make_coord_delta(boundary)
except ValueError:
raise ValueError(
"Invalid boundary for dimension '%s' ('%s' is not a valid coordinate delta)"
% (dim, boundary))
if np.array(delta).astype(float) < 0:
raise ValueError(
"Invalid boundary for dimension '%s' (%s < 0)" %
(dim, delta))
if np.array(boundary).ndim == 1:
make_coord_delta_array(boundary)
raise NotImplementedError(
"Non-centered boundary not yet supported for dimension '%s'"
% dim)
if np.array(boundary).ndim == 2:
for elem in boundary:
make_coord_delta_array(elem)
raise NotImplementedError(
"Non-uniform boundary not yet supported for dimension '%s'"
% dim)
return val
def __init__(self, start, stop, step=None, size=None, name=None):
"""
Create uniformly-spaced 1d coordinates from a `start`, `stop`, and `step` or `size`.
Parameters
----------
start : float or datetime64
Start coordinate.
stop : float or datetime64
Stop coordinate.
step : float or timedelta64
Signed, nonzero step between coordinates (either step or size required).
size : int
Number of coordinates (either step or size required).
name : str, optional
Dimension name, one of 'lat', 'lon', 'time', or 'alt'.
"""
if step is not None and size is not None:
raise TypeError("only one of 'step' and 'size' is allowed")
elif step is None and size is None:
raise TypeError("'step' or 'size' is required")
# validate and set start, stop, and step
start = make_coord_value(start)
stop = make_coord_value(stop)
if step is not None:
step = make_coord_delta(step)
elif isinstance(size, (int, np.long, np.integer)) and not isinstance(size, np.timedelta64):
step = divide_delta(stop - start, size - 1)
else:
raise TypeError("size must be an integer, not '%s'" % type(size))
if isinstance(start, float) and isinstance(stop, float) and isinstance(step, float):
fstep = step
elif isinstance(start, np.datetime64) and isinstance(stop, np.datetime64) and isinstance(step, np.timedelta64):
fstep = step.astype(float)
else:
raise TypeError(
"UniformCoordinates1d mismatching types (start '%s', stop '%s', step '%s')."
% (type(start), type(stop), type(step))
)
if fstep == 0:
raise ValueError("Uniformcoordinates1d step cannot be zero")
if fstep <= 0 and start < stop:
raise ValueError("UniformCoordinates1d step must be greater than zero if start < stop.")
if fstep >= 0 and start > stop:
raise ValueError("UniformCoordinates1d step must be less than zero if start > stop.")
self.set_trait("start", start)
self.set_trait("stop", stop)
self.set_trait("step", step)
# set common properties
super(UniformCoordinates1d, self).__init__(name=name)
def _time_to_float(self, time, time_source, time_request):
dtype0 = time_source.coordinates[0].dtype
dtype1 = time_request.coordinates[0].dtype
dtype = dtype0 if dtype0 > dtype1 else dtype1
time = make_coord_delta(time)
if isinstance(time, np.timedelta64):
time1 = (time + np.datetime64("2000")).astype(dtype).astype(
float) - (np.datetime64("2000").astype(dtype).astype(float))
return time1
def from_tuple(cls, items, **kwargs):
if not isinstance(items, tuple) or len(items) != 3:
raise ValueError(
"UniformCoordinates1d.from_tuple expects a tuple of (start, stop, step/size), got %s" % (items,)
)
elif isinstance(items[2], int):
return cls(items[0], items[1], size=items[2], **kwargs)
else:
step = make_coord_delta(items[2])
return cls(items[0], items[1], step, **kwargs)
def get_area_bounds(self, boundary):
"""
Get low and high coordinate area bounds.
Arguments
---------
boundary : float, timedelta, array, None
Boundary offsets in this dimension.
* For a centered uniform boundary (same for every coordinate), use a single positive float or timedelta
offset. This represents the "total segment length" / 2.
* For a uniform boundary (segment or polygon same for every coordinate), use an array of float or
timedelta offsets
* For a fully specified boundary, use an array of boundary arrays (2-D array, N_coords x boundary spec),
one per coordinate. The boundary_spec can be a single number, two numbers, or an array of numbers.
* For point coordinates, use None.
Returns
-------
low: float, np.datetime64
low area bound
high: float, np.datetime64
high area bound
"""
# point coordinates
if boundary is None:
return self.bounds
# empty coordinates
if self.size == 0:
return self.bounds
if np.array(boundary).ndim == 0:
# shortcut for uniform centered boundary
boundary = make_coord_delta(boundary)
lo_offset = -boundary
hi_offset = boundary
elif np.array(boundary).ndim == 1:
# uniform boundary polygon
boundary = make_coord_delta_array(boundary)
lo_offset = min(boundary)
hi_offset = max(boundary)
else:
L, H = self.argbounds
lo_offset = min(make_coord_delta_array(boundary[L]))
hi_offset = max(make_coord_delta_array(boundary[H]))
lo, hi = self.bounds
lo = add_coord(lo, lo_offset)
hi = add_coord(hi, hi_offset)
return lo, hi
def __init__(self, start, stop, step=None, size=None, name=None, fix_stop_val=False):
"""
Create uniformly-spaced 1d coordinates from a `start`, `stop`, and `step` or `size`.
Parameters
----------
start : float or datetime64
Start coordinate.
stop : float or datetime64
Stop coordinate.
step : float or timedelta64
Signed, nonzero step between coordinates (either step or size required).
size : int
Number of coordinates (either step or size required).
name : str, optional
Dimension name, one of 'lat', 'lon', 'time', or 'alt'.
fix_stop_val : bool, optional
Default is False. If True, the constructor will modify the step to be consistent
instead of the stop value. Otherwise, the stop value *may* be modified to ensure that
stop = start + step * size
Notes
------
When the user specifies fix_stop_val, then `stop` will always be exact as specified by the user.
For floating point coordinates, the specified `step` my be changed internally to satisfy floating point consistency.
That is, for consistency `step = (stop - start) / (size - 1)`
"""
if step is not None and size is not None:
raise TypeError("only one of 'step' and 'size' is allowed")
elif step is None and size is None:
raise TypeError("'step' or 'size' is required")
# validate and set start, stop, and step
start = make_coord_value(start)
stop = make_coord_value(stop)
if step is not None:
step = make_coord_delta(step)
elif isinstance(size, (int, np.compat.long, np.integer)) and not isinstance(size, np.timedelta64):
step = divide_delta(stop - start, size - 1)
else:
raise TypeError("size must be an integer, not '%s'" % type(size))
if isinstance(start, float) and isinstance(stop, float) and isinstance(step, float):
fstep = step
elif isinstance(start, np.datetime64) and isinstance(stop, np.datetime64) and isinstance(step, np.timedelta64):
fstep = step.astype(float)
else:
raise TypeError(
"UniformCoordinates1d mismatching types (start '%s', stop '%s', step '%s')."
% (type(start), type(stop), type(step))
)
if fstep == 0:
raise ValueError("Uniformcoordinates1d step cannot be zero")
if fstep <= 0 and start < stop:
raise ValueError("UniformCoordinates1d step must be greater than zero if start < stop.")
if fstep >= 0 and start > stop:
raise ValueError("UniformCoordinates1d step must be less than zero if start > stop.")
self.set_trait("start", start)
self.set_trait("stop", stop)
self.set_trait("step", step)
if not fix_stop_val: # Need to make sure that 'stop' is consistent with self.coordinates[-1]
self.set_trait("stop", add_coord(self.start, (self.size - 1) * self.step))
# Make sure step is floating-point error consistent in all cases
# This is only needed when the type is float
if fstep == step and self.size > 1:
step = divide_delta(self.stop - self.start, self.size - 1)
self.set_trait("step", step)
# set common properties
super(UniformCoordinates1d, self).__init__(name=name)
def test_make_coord_delta():
# numbers
assert make_coord_delta(10.5) == 10.5
assert make_coord_delta(10) == 10.0
assert make_coord_delta(np.array(10.5)) == 10.5
assert make_coord_delta(np.array([10.5])) == 10.5
assert type(make_coord_delta(10.5)) is float
assert type(make_coord_delta(10)) is float
assert type(make_coord_delta(np.array(10.5))) is float
assert type(make_coord_delta(np.array([10.5]))) is float
# timedelta
td = np.timedelta64(2, 'D')
assert make_coord_delta(td) == td
assert make_coord_delta(td.item()) == td
assert make_coord_delta('2,D') == td
assert make_coord_delta(u'2,D') == td
assert make_coord_delta(np.array(td)) == td
assert make_coord_delta(np.array([td])) == td
assert make_coord_delta(np.array('2,D')) == td
assert make_coord_delta(np.array(['2,D'])) == td
# arrays and lists
with pytest.raises(TypeError, match="Invalid coordinate delta"):
make_coord_delta(np.arange(5))
with pytest.raises(TypeError, match="Invalid coordinate delta"):
make_coord_delta(range(5))
# invalid strings
with pytest.raises(ValueError):
make_coord_delta('not a valid timedelta')
def __init__(self,
start,
stop,
step=None,
size=None,
name=None,
ctype=None,
units=None,
coord_ref_sys=None,
segment_lengths=None):
"""
Create uniformly-spaced 1d coordinates from a `start`, `stop`, and `step` or `size`.
Parameters
----------
start : float or datetime64
Start coordinate.
stop : float or datetime64
Stop coordinate.
step : float or timedelta64
Signed, nonzero step between coordinates (either step or size required).
size : int
Number of coordinates (either step or size required).
segment_lengths: array, float, timedelta, optional
When ctype is a segment type, the segment lengths for the coordinates. By defaul, the segment_lengths are
equal the step.
"""
if step is not None and size is not None:
raise TypeError("only one of 'step' and 'size' is allowed")
elif step is None and size is None:
raise TypeError("'step' or 'size' is required")
# validate and set start, stop, and step
start = make_coord_value(start)
stop = make_coord_value(stop)
if step == 0:
raise ValueError("step must be nonzero")
elif step is not None:
step = make_coord_delta(step)
elif isinstance(size,
(int, np.long,
np.integer)) and not isinstance(size, np.timedelta64):
step = divide_delta(stop - start, size - 1)
else:
raise TypeError("size must be an integer, not '%s'" % type(size))
if isinstance(start, float) and isinstance(stop, float) and isinstance(
step, float):
fstep = step
elif isinstance(start, np.datetime64) and isinstance(
stop, np.datetime64) and isinstance(step, np.timedelta64):
fstep = step.astype(float)
else:
raise TypeError(
"UniformCoordinates1d mismatching types (start '%s', stop '%s', step '%s')."
% (type(start), type(stop), type(step)))
if fstep < 0 and start < stop:
raise ValueError(
"UniformCoordinates1d step must be less than zero if start > stop."
)
if fstep > 0 and start > stop:
raise ValueError(
"UniformCoordinates1d step must be greater than zero if start < stop."
)
self.set_trait('start', start)
self.set_trait('stop', stop)
self.set_trait('step', step)
# set common properties
super(UniformCoordinates1d,
self).__init__(name=name,
ctype=ctype,
units=units,
segment_lengths=segment_lengths,
coord_ref_sys=coord_ref_sys)