FDataIrregular#
- class skfda.representation.irregular.FDataIrregular(start_indices, points, values, *, domain_range=None, dataset_name=None, sample_names=None, extrapolation=None, interpolation=None, argument_names=None, coordinate_names=None)[source]#
Represent discretised functional data of an irregular or sparse nature.
Class for representing irregular functional data in a compact manner, allowing basic operations, representation and conversion to basis format.
- Attributes:
start_indices – A unidimensional array which stores the index of the functional_values and functional_values arrays where the data of each individual curve of the sample begins.
points – An array of every argument of the domain for every curve in the sample. Each row contains an observation.
values – An array of every value of the codomain for every curve in the sample. Each row contains an observation.
domain_range – 2 dimension matrix where each row contains the bounds of the interval in which the functional data is considered to exist for each one of the axes.
dataset_name – Name of the dataset.
argument_names – Tuple containing the names of the different arguments.
coordinate_names – Tuple containing the names of the different coordinate functions.
extrapolation – Defines the default type of extrapolation. By default None, which does not apply any type of extrapolation. See Extrapolation for detailled information of the types of extrapolation.
interpolation – Defines the type of interpolation applied in evaluate.
- Raises:
if points and values lengths don’t match - if start_indices does’nt start with 0, or is decreasing somewhere, or ends with a value greater than or equal to len(points).
- Parameters:
start_indices (ArrayLike) –
points (ArrayLike) –
values (ArrayLike) –
domain_range (Optional[DomainRangeLike]) –
dataset_name (str | None) –
sample_names (Optional[LabelTupleLike]) –
extrapolation (Optional[ExtrapolationLike]) –
interpolation (Optional[Evaluator]) –
argument_names (Optional[LabelTupleLike]) –
coordinate_names (Optional[LabelTupleLike]) –
Examples
Representation of an irregular functional data object with 2 samples representing a function \(f : \mathbb{R}\longmapsto\mathbb{R}\), with 2 and 3 discretization points respectively.
>>> indices = [0, 2] >>> arguments = [[1], [2], [3], [4], [5]] >>> values = [[1], [2], [3], [4], [5]] >>> FDataIrregular(indices, arguments, values) FDataIrregular( start_indices=array([0, 2]), points=array([[1], [2], [3], [4], [5]]), values=array([[1], [2], [3], [4], [5]]), domain_range=((1.0, 5.0),), ...)
The number of arguments and values must be the same.
>>> indices = [0,2] >>> arguments = np.arange(5).reshape(-1, 1) >>> values = np.arange(6).reshape(-1, 1) >>> FDataIrregular(indices, arguments, values) Traceback (most recent call last): .... ValueError: Dimension mismatch ...
The indices in start_indices must point to correct rows in points and values.
>>> indices = [0,7] >>> arguments = np.arange(5).reshape(-1, 1) >>> values = np.arange(5).reshape(-1, 1) >>> FDataIrregular(indices, arguments, values) Traceback (most recent call last): .... ValueError: Index in start_indices out of bounds...
FDataIrregular supports higher dimensional data both in the domain and in the codomain (image).
Representation of a functional data object with 2 samples representing a function \(f : \mathbb{R}\longmapsto\mathbb{R}^2\).
>>> indices = [0, 2] >>> arguments = [[1.], [2.], [3.], [4.], [5.]] >>> values = [[1., 1.], [2., 2.], [3., 3.], [4., 4.], [5., 5.]] >>> fd = FDataIrregular(indices, arguments, values) >>> fd.dim_domain, fd.dim_codomain (1, 2)
Representation of a functional data object with 2 samples representing a function \(f : \mathbb{R}^2\longmapsto\mathbb{R}\).
>>> indices = [0, 2] >>> arguments = [[1., 1.], [2., 2.], [3., 3.], [4., 4.], [5., 5.]] >>> values = [[1.], [2.], [3.], [4.], [5.]] >>> fd = FDataIrregular(indices, arguments, values) >>> fd.dim_domain, fd.dim_codomain (2, 1)
Methods
argmax
([skipna])Return the index of maximum value.
argmin
([skipna])Return the index of minimum value.
argsort
(*[, ascending, kind, na_position])Return the indices that would sort this array.
astype
(dtype[, copy])Cast to a new dtype.
check_same_dimensions
(other)Ensure that other FDataIrregular object has compatible dimensions.
compose
(fd, *[, eval_points])Composition of functions.
concatenate
(*others[, as_coordinates])Join samples from a similar FDataIrregular object.
copy
([start_indices, points, values, deep, ...])Return a copy of the FDataIrregular.
cov
()Compute the covariance for a FDataIrregular object.
delete
(loc)derivative
([order, method])Differentiate the FDataIrregular object.
dropna
()Return ExtensionArray without NA values.
duplicated
([keep])Return boolean ndarray denoting duplicate values.
equals
(other)Comparison of FDataIrregular objects.
evaluate
(eval_points, *[, derivative, ...])Evaluate the object at a list of values or a grid.
factorize
([use_na_sentinel])Encode the extension array as an enumerated type.
fillna
([value, method, limit, copy])Fill NA/NaN values using the specified method.
from_fdatagrid
(f_data, **kwargs)Create a FDataIrregular object from a source FDataGrid.
insert
(loc, item)Insert an item at the given position.
integrate
(*[, domain])Integrate the FDataIrregular object.
interpolate
(*, method, axis, index, limit, ...)See DataFrame.interpolate.__doc__.
isin
(values)Pointwise comparison for set containment in the given values.
isna
()Return a 1-D array indicating if each value is missing.
map
(mapper[, na_action])Map values using an input mapping or function.
mean
(*[, axis, dtype, out, keepdims, skipna])Compute the mean of all the samples.
plot
(*args, **kwargs)Plot the functional data of FDataIrregular with a lines plot.
ravel
([order])Return a flattened view on this array.
repeat
(repeats[, axis])Repeat elements of a ExtensionArray.
restrict
(domain_range, *[, with_bounds])Restrict the functions to a new domain range.
round
([decimals, out])Evenly round values to the given number of decimals.
scatter
(*args, **kwargs)Plot the functional data of FDataIrregular with a scatter plot.
searchsorted
(value[, side, sorter])Find indices where elements should be inserted to maintain order.
shift
(shifts, *[, restrict_domain, ...])Perform a shift of the curves.
sum
(*[, axis, out, keepdims, skipna, min_count])Compute the sum of all the samples.
take
(indices[, allow_fill, fill_value, axis])Take elements from an array.
to_basis
(basis, **kwargs)Return the basis representation of the object.
to_grid
()Convert FDataIrregular to FDataGrid.
to_numpy
([dtype, copy, na_value])Convert to a NumPy ndarray.
tolist
()Return a list of the values.
transpose
(*axes)Return a transposed view on this array.
unique
()Compute the ExtensionArray of unique values.
var
([correction])Compute the variance of all the samples.
view
([dtype])Return a view on the array.
- argmax(skipna=True)#
Return the index of maximum value.
In case of multiple occurrences of the maximum value, the index corresponding to the first occurrence is returned.
See also
ExtensionArray.argmin
Return the index of the minimum value.
Examples
>>> arr = pd.array([3, 1, 2, 5, 4]) >>> arr.argmax() 3
- argmin(skipna=True)#
Return the index of minimum value.
In case of multiple occurrences of the minimum value, the index corresponding to the first occurrence is returned.
See also
ExtensionArray.argmax
Return the index of the maximum value.
Examples
>>> arr = pd.array([3, 1, 2, 5, 4]) >>> arr.argmin() 1
- argsort(*, ascending=True, kind='quicksort', na_position='last', **kwargs)#
Return the indices that would sort this array.
- Parameters:
ascending (bool, default True) – Whether the indices should result in an ascending or descending sort.
kind ({'quicksort', 'mergesort', 'heapsort', 'stable'}, optional) – Sorting algorithm.
na_position ({'first', 'last'}, default 'last') – If
'first'
, putNaN
values at the beginning. If'last'
, putNaN
values at the end.*args – Passed through to
numpy.argsort()
.**kwargs – Passed through to
numpy.argsort()
.
- Returns:
Array of indices that sort
self
. If NaN values are contained, NaN values are placed at the end.- Return type:
np.ndarray[np.intp]
See also
numpy.argsort
Sorting implementation used internally.
Examples
>>> arr = pd.array([3, 1, 2, 5, 4]) >>> arr.argsort() array([1, 2, 0, 4, 3])
- check_same_dimensions(other)[source]#
Ensure that other FDataIrregular object has compatible dimensions.
- Parameters:
other (T) – FDataIrregular object to compare dimensions with.
self (T) –
- Raises:
ValueError – Dimension mismatch in coordinates.
ValueError – Dimension mismatch in arguments.
- Return type:
None
- compose(fd, *, eval_points=None)[source]#
Composition of functions.
Performs the composition of functions.
- Parameters:
fd (T) – FData object to make the composition. Should have the same number of samples and image dimension equal to 1.
eval_points (Union[ArrayLike, Sequence[ArrayLike]] | None) – Points to perform the evaluation.
self (T) –
- Returns:
Function representing the composition.
- Return type:
T
- concatenate(*others, as_coordinates=False)[source]#
Join samples from a similar FDataIrregular object.
Joins samples from another FDataIrregular object if it has the same dimensions.
- Parameters:
others (T) – Objects to be concatenated.
as_coordinates (bool) – If False concatenates as new samples, else, concatenates the other functions as new components of the image. Defaults to false.
self (T) –
- Raises:
NotImplementedError – Not implemented for as_coordinates = True
- Returns:
FDataIrregular object with the samples from the source objects.
- Return type:
T
Examples
>>> indices = [0, 2] >>> arguments = values = np.arange(5.).reshape(-1, 1) >>> fd = FDataIrregular(indices, arguments, values) >>> arguments_2 = values_2 = np.arange(5, 10).reshape(-1, 1) >>> fd_2 = FDataIrregular(indices, arguments_2, values_2) >>> fd.concatenate(fd_2) FDataIrregular( start_indices=array([0, 2, 5, 7]), points=array([[ 0.], [ 1.], [ 2.], [ 3.], [ 4.], [ 5.], [ 6.], [ 7.], [ 8.], [ 9.]]), values=array([[ 0.], [ 1.], [ 2.], [ 3.], [ 4.], [ 5.], [ 6.], [ 7.], [ 8.], [ 9.]]), domain_range=((0.0, 9.0),), ...)
- copy(start_indices=None, points=None, values=None, deep=False, domain_range=None, dataset_name=None, sample_names=None, extrapolation=None, interpolation=None, argument_names=None, coordinate_names=None)[source]#
Return a copy of the FDataIrregular.
If an argument is provided the corresponding attribute in the new copy is updated.
- Parameters:
self (T) –
start_indices (ArrayLike | None) –
points (ArrayLike | None) –
values (ArrayLike | None) –
deep (bool) –
domain_range (Tuple[Tuple[float, float], ...] | Sequence[float] | Sequence[Sequence[float]] | None) –
dataset_name (str | None) –
extrapolation (Evaluator | Literal['bounds', 'exception', 'nan', 'none', 'periodic', 'zeros'] | None) –
interpolation (Evaluator | None) –
- Return type:
T
- cov()[source]#
Compute the covariance for a FDataIrregular object.
- Returns:
FDataIrregular with the covariance function.
- Parameters:
self (T) –
- Return type:
T
- delete(loc)#
- Parameters:
loc (PositionalIndexer) –
- Return type:
Self
- dropna()#
Return ExtensionArray without NA values.
Examples
>>> pd.array([1, 2, np.nan]).dropna() <IntegerArray> [1, 2] Length: 2, dtype: Int64
- Return type:
Self
- duplicated(keep='first')#
Return boolean ndarray denoting duplicate values.
- Parameters:
keep ({'first', 'last', False}, default 'first') –
first
: Mark duplicates asTrue
except for the first occurrence.last
: Mark duplicates asTrue
except for the last occurrence.False : Mark all duplicates as
True
.
- Return type:
ndarray[bool]
Examples
>>> pd.array([1, 1, 2, 3, 3], dtype="Int64").duplicated() array([False, True, False, False, True])
- evaluate(eval_points, *, derivative=0, extrapolation=None, grid=False, aligned=True)[source]#
Evaluate the object at a list of values or a grid.
Deprecated since version 0.8: Use normal calling notation instead.
- Parameters:
eval_points (_SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | bool | int | float | complex | str | bytes | _NestedSequence[bool | int | float | complex | str | bytes] | Sequence[_SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | bool | int | float | complex | str | bytes | _NestedSequence[bool | int | float | complex | str | bytes]] | Iterable[_SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | bool | int | float | complex | str | bytes | _NestedSequence[bool | int | float | complex | str | bytes] | Sequence[_SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | bool | int | float | complex | str | bytes | _NestedSequence[bool | int | float | complex | str | bytes]]]) – List of points where the functions are evaluated. If
grid
isTrue
, a list of axes, one per domain dimension, must be passed instead. Ifaligned
isTrue
, then a list of lists (of points or axes, as explained) must be passed, with one list per sample.derivative (int) – Deprecated. Order of the derivative to evaluate.
extrapolation (Evaluator | Literal['bounds', 'exception', 'nan', 'none', 'periodic', 'zeros'] | None) – Controls the extrapolation mode for elements outside the domain range. By default it is used the mode defined during the instance of the object.
grid (bool) – Whether to evaluate the results on a grid spanned by the input arrays, or at points specified by the input arrays. If true the eval_points should be a list of size dim_domain with the corresponding times for each axis. The return matrix has shape n_samples x len(t1) x len(t2) x … x len(t_dim_domain) x dim_codomain. If the domain dimension is 1 the parameter has no efect. Defaults to False.
aligned (bool) – Whether the input points are the same for each sample, or an array of points per sample is passed.
- Returns:
Matrix whose rows are the values of the each function at the values specified in eval_points.
- Return type:
- factorize(use_na_sentinel=True)#
Encode the extension array as an enumerated type.
- Parameters:
use_na_sentinel (bool, default True) –
If True, the sentinel -1 will be used for NaN values. If False, NaN values will be encoded as non-negative integers and will not drop the NaN from the uniques of the values.
New in version 1.5.0.
- Returns:
codes (ndarray) – An integer NumPy array that’s an indexer into the original ExtensionArray.
uniques (ExtensionArray) – An ExtensionArray containing the unique values of self.
Note
uniques will not contain an entry for the NA value of the ExtensionArray if there are any missing values present in self.
- Return type:
See also
factorize
Top-level factorize method that dispatches here.
Notes
pandas.factorize()
offers a sort keyword as well.Examples
>>> idx1 = pd.PeriodIndex(["2014-01", "2014-01", "2014-02", "2014-02", ... "2014-03", "2014-03"], freq="M") >>> arr, idx = idx1.factorize() >>> arr array([0, 0, 1, 1, 2, 2]) >>> idx PeriodIndex(['2014-01', '2014-02', '2014-03'], dtype='period[M]')
- fillna(value=None, method=None, limit=None, copy=True)#
Fill NA/NaN values using the specified method.
- Parameters:
value (scalar, array-like) – If a scalar value is passed it is used to fill all missing values. Alternatively, an array-like “value” can be given. It’s expected that the array-like have the same length as ‘self’.
method ({'backfill', 'bfill', 'pad', 'ffill', None}, default None) –
Method to use for filling holes in reindexed Series:
pad / ffill: propagate last valid observation forward to next valid.
backfill / bfill: use NEXT valid observation to fill gap.
Deprecated since version 2.1.0.
limit (int, default None) –
If method is specified, this is the maximum number of consecutive NaN values to forward/backward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. If method is not specified, this is the maximum number of entries along the entire axis where NaNs will be filled.
Deprecated since version 2.1.0.
copy (bool, default True) – Whether to make a copy of the data before filling. If False, then the original should be modified and no new memory should be allocated. For ExtensionArray subclasses that cannot do this, it is at the author’s discretion whether to ignore “copy=False” or to raise. The base class implementation ignores the keyword in pad/backfill cases.
- Returns:
With NA/NaN filled.
- Return type:
ExtensionArray
Examples
>>> arr = pd.array([np.nan, np.nan, 2, 3, np.nan, np.nan]) >>> arr.fillna(0) <IntegerArray> [0, 0, 2, 3, 0, 0] Length: 6, dtype: Int64
- classmethod from_fdatagrid(f_data, **kwargs)[source]#
Create a FDataIrregular object from a source FDataGrid.
- Parameters:
f_data (FDataGrid) – FDataGrid object used as source.
kwargs – Arguments for the FDataIrregular constructor.
- Returns:
FDataIrregular containing the same data as the source but with an irregular structure.
- Return type:
- insert(loc, item)#
Insert an item at the given position.
- Parameters:
loc (int) –
item (scalar-like) –
- Return type:
same type as self
Notes
This method should be both type and dtype-preserving. If the item cannot be held in an array of this type/dtype, either ValueError or TypeError should be raised.
The default implementation relies on _from_sequence to raise on invalid items.
Examples
>>> arr = pd.array([1, 2, 3]) >>> arr.insert(2, -1) <IntegerArray> [1, 2, -1, 3] Length: 4, dtype: Int64
- integrate(*, domain=None)[source]#
Integrate the FDataIrregular object.
The integration can only be performed over 1 dimensional domains.
For a vector valued function the vector of integrals will be returned.
- Parameters:
- Returns:
NumPy array of size (
n_samples
,dim_codomain
) with the integrated data.- Return type:
Examples
>>> fdata = FDataIrregular( ... values=[[2, -1], [2, 3], [5, -2], [1, -1], [1, -1]], ... points=[[4], [5], [6], [0], [2]], ... start_indices=[0, 3], ... ) >>> fdata.integrate() array([[ 5., 3.], [ 2., -2.]])
- interpolate(*, method, axis, index, limit, limit_direction, limit_area, copy, **kwargs)#
See DataFrame.interpolate.__doc__.
Examples
>>> arr = pd.arrays.NumpyExtensionArray(np.array([0, 1, np.nan, 3])) >>> arr.interpolate(method="linear", ... limit=3, ... limit_direction="forward", ... index=pd.Index([1, 2, 3, 4]), ... fill_value=1, ... copy=False, ... axis=0, ... limit_area="inside" ... ) <NumpyExtensionArray> [0.0, 1.0, 2.0, 3.0] Length: 4, dtype: float64
- isin(values)#
Pointwise comparison for set containment in the given values.
Roughly equivalent to np.array([x in values for x in self])
- Parameters:
values (np.ndarray or ExtensionArray) –
- Return type:
np.ndarray[bool]
Examples
>>> arr = pd.array([1, 2, 3]) >>> arr.isin([1]) <BooleanArray> [True, False, False] Length: 3, dtype: boolean
- isna()[source]#
Return a 1-D array indicating if each value is missing.
- Returns:
Positions of NA.
- Return type:
na_values (NDArrayBool)
- map(mapper, na_action=None)#
Map values using an input mapping or function.
- Parameters:
mapper (function, dict, or Series) – Mapping correspondence.
na_action ({None, 'ignore'}, default None) – If ‘ignore’, propagate NA values, without passing them to the mapping correspondence. If ‘ignore’ is not supported, a
NotImplementedError
should be raised.
- Returns:
The output of the mapping function applied to the array. If the function returns a tuple with more than one element a MultiIndex will be returned.
- Return type:
Union[ndarray, Index, ExtensionArray]
- mean(*, axis=None, dtype=None, out=None, keepdims=False, skipna=False)[source]#
Compute the mean of all the samples.
- Parameters:
axis (int | None) – Used for compatibility with numpy. Must be None or 0.
dtype (None) – Used for compatibility with numpy. Must be None.
out (None) – Used for compatibility with numpy. Must be None.
keepdims (bool) – Used for compatibility with numpy. Must be False.
skipna (bool) – Wether the NaNs are ignored or not.
self (T) –
- Returns:
A FData object with just one sample representing the mean of all the samples in the original object.
- Return type:
T
- ravel(order='C')#
Return a flattened view on this array.
- Parameters:
order ({None, 'C', 'F', 'A', 'K'}, default 'C') –
- Return type:
ExtensionArray
Notes
Because ExtensionArrays are 1D-only, this is a no-op.
The “order” argument is ignored, is for compatibility with NumPy.
Examples
>>> pd.array([1, 2, 3]).ravel() <IntegerArray> [1, 2, 3] Length: 3, dtype: Int64
- repeat(repeats, axis=None)#
Repeat elements of a ExtensionArray.
Returns a new ExtensionArray where each element of the current ExtensionArray is repeated consecutively a given number of times.
- Parameters:
repeats (int or array of ints) – The number of repetitions for each element. This should be a non-negative integer. Repeating 0 times will return an empty ExtensionArray.
axis (None) – Must be
None
. Has no effect but is accepted for compatibility with numpy.
- Returns:
Newly created ExtensionArray with repeated elements.
- Return type:
ExtensionArray
See also
Series.repeat
Equivalent function for Series.
Index.repeat
Equivalent function for Index.
numpy.repeat
Similar method for
numpy.ndarray
.ExtensionArray.take
Take arbitrary positions.
Examples
>>> cat = pd.Categorical(['a', 'b', 'c']) >>> cat ['a', 'b', 'c'] Categories (3, object): ['a', 'b', 'c'] >>> cat.repeat(2) ['a', 'a', 'b', 'b', 'c', 'c'] Categories (3, object): ['a', 'b', 'c'] >>> cat.repeat([1, 2, 3]) ['a', 'b', 'b', 'c', 'c', 'c'] Categories (3, object): ['a', 'b', 'c']
- round(decimals=0, out=None)[source]#
Evenly round values to the given number of decimals.
Arguments are not rounded due to possibility of coalescing various arguments to the same rounded value.
Deprecated since version 0.6: Use
numpy.round()
function instead.- Parameters:
decimals (int) – Number of decimal places to round to. If decimals is negative, it specifies the number of positions to the left of the decimal point. Defaults to 0.
out (FDataIrregular | None) – FDataIrregular where to place the result, if any.
- Returns:
Returns a FDataIrregular object where all elements in its values are rounded.
- Return type:
- searchsorted(value, side='left', sorter=None)#
Find indices where elements should be inserted to maintain order.
Find the indices into a sorted array self (a) such that, if the corresponding elements in value were inserted before the indices, the order of self would be preserved.
Assuming that self is sorted:
side
returned index i satisfies
left
self[i-1] < value <= self[i]
right
self[i-1] <= value < self[i]
- Parameters:
value (array-like, list or scalar) – Value(s) to insert into self.
side ({'left', 'right'}, optional) – If ‘left’, the index of the first suitable location found is given. If ‘right’, return the last such index. If there is no suitable index, return either 0 or N (where N is the length of self).
sorter (1-D array-like, optional) – Optional array of integer indices that sort array a into ascending order. They are typically the result of argsort.
- Returns:
If value is array-like, array of insertion points. If value is scalar, a single integer.
- Return type:
array of ints or int
See also
numpy.searchsorted
Similar method from NumPy.
Examples
>>> arr = pd.array([1, 2, 3, 5]) >>> arr.searchsorted([4]) array([3])
- shift(shifts, *, restrict_domain=False, extrapolation=None)[source]#
Perform a shift of the curves.
The i-th shifted function \(y_i\) has the form
\[y_i(t) = x_i(t + \delta_i)\]where \(x_i\) is the i-th original function and \(delta_i\) is the shift performed for that function, that must be a vector in the domain space.
Note that a positive shift moves the graph of the function in the negative direction and vice versa.
- Parameters:
shifts (ArrayLike | float) – List with the shifts corresponding for each sample or numeric with the shift to apply to all samples.
restrict_domain (bool) – If True restricts the domain to avoid the evaluation of points outside the domain using extrapolation. Defaults uses extrapolation.
extrapolation (Evaluator | Literal['bounds', 'exception', 'nan', 'none', 'periodic', 'zeros'] | None) – Controls the extrapolation mode for elements outside the domain range. By default uses the method defined in fd. See extrapolation to more information.
- Returns:
Shifted functions.
- Return type:
- sum(*, axis=None, out=None, keepdims=False, skipna=False, min_count=0)[source]#
Compute the sum of all the samples.
- Parameters:
axis (Optional[int]) – Used for compatibility with numpy. Must be None or 0.
out (None) – Used for compatibility with numpy. Must be None.
keepdims (bool) – Used for compatibility with numpy. Must be False.
skipna (bool) – Wether the NaNs are ignored or not.
min_count (int) – Number of valid (non NaN) data to have in order for the a variable to not be NaN when skipna is True.
self (T) –
- Returns:
- FDataIrregular object with only one curve and one value
representing the sum of all the samples in the original object. The points of the new object are the points common to all the samples in the original object. Only values present in those common points are considered for the sum.
- Return type:
T
- take(indices, allow_fill=False, fill_value=None, axis=0)[source]#
Take elements from an array.
- Parameters:
indices (int | Sequence[int] | ndarray[Any, dtype[int64]]) – Indices to be taken.
allow_fill (bool) –
How to handle negative values in indices.
False: negative values in indices indicate positional indices from the right (the default). This is similar to
numpy.take()
.True: negative values in indices indicate missing values. These values are set to fill_value. Any other negative values raise a
ValueError
.
fill_value (T | None) – Fill value to use for NA-indices when allow_fill is True. This may be
None
, in which case the default NA value for the type,self.dtype.na_value
, is used. For many ExtensionArrays, there will be two representations of fill_value: a user-facing “boxed” scalar, and a low-level physical NA value. fill_value should be the user-facing version, and the implementation should handle translating that to the physical version for processing the take if necessary.axis (int) – Parameter for compatibility with numpy. Must be always 0.
self (T) –
- Returns:
FData
- Raises:
IndexError – When the indices are out of bounds for the array.
ValueError – When indices contains negative values other than
-1
and allow_fill is True.
- Return type:
T
Notes
ExtensionArray.take is called by
Series.__getitem__
,.loc
,iloc
, when indices is a sequence of values. Additionally, it’s called bySeries.reindex()
, or any other method that causes realignment, with a fill_value.See also
numpy.take pandas.api.extensions.take
- to_basis(basis, **kwargs)[source]#
Return the basis representation of the object.
- Parameters:
- Raises:
ValueError – Incorrect domain dimension
ValueError – Incorrect codomain dimension
- Returns:
Basis representation of the funtional data object.
- Return type:
- to_grid()[source]#
Convert FDataIrregular to FDataGrid.
Undefined values in the grid will be represented with np.nan.
- Returns:
FDataGrid with the irregular functional data.
- Return type:
- Parameters:
self (T) –
- to_numpy(dtype=None, copy=False, na_value=_NoDefault.no_default)#
Convert to a NumPy ndarray.
This is similar to
numpy.asarray()
, but may provide additional control over how the conversion is done.- Parameters:
dtype (str or numpy.dtype, optional) – The dtype to pass to
numpy.asarray()
.copy (bool, default False) – Whether to ensure that the returned value is a not a view on another array. Note that
copy=False
does not ensure thatto_numpy()
is no-copy. Rather,copy=True
ensure that a copy is made, even if not strictly necessary.na_value (Any, optional) – The value to use for missing values. The default value depends on dtype and the type of the array.
- Return type:
- tolist()#
Return a list of the values.
These are each a scalar type, which is a Python scalar (for str, int, float) or a pandas scalar (for Timestamp/Timedelta/Interval/Period)
- Return type:
Examples
>>> arr = pd.array([1, 2, 3]) >>> arr.tolist() [1, 2, 3]
- transpose(*axes)#
Return a transposed view on this array.
Because ExtensionArrays are always 1D, this is a no-op. It is included for compatibility with np.ndarray.
- Return type:
ExtensionArray
- Parameters:
axes (int) –
Examples
>>> pd.array([1, 2, 3]).transpose() <IntegerArray> [1, 2, 3] Length: 3, dtype: Int64
- unique()#
Compute the ExtensionArray of unique values.
- Return type:
Examples
>>> arr = pd.array([1, 2, 3, 1, 2, 3]) >>> arr.unique() <IntegerArray> [1, 2, 3] Length: 3, dtype: Int64
- var(correction=0)[source]#
Compute the variance of all the samples.
- Parameters:
correction (int) – degrees of freedom adjustment. The divisor used in the calculation is N - correction, where N represents the number of elements. Default: 0.
self (T) –
- Returns:
- FDataIrregular object with only one curve and one value
representing the pointwise variance of all the samples in the original object. The points of the new object are the points common to all the samples in the original object.
- Return type:
T
- view(dtype=None)#
Return a view on the array.
- Parameters:
dtype (str, np.dtype, or ExtensionDtype, optional) – Default None.
- Returns:
A view on the
ExtensionArray
’s data.- Return type:
ExtensionArray or np.ndarray
Examples
This gives view on the underlying data of an
ExtensionArray
and is not a copy. Modifications on either the view or the originalExtensionArray
will be reflectd on the underlying data:>>> arr = pd.array([1, 2, 3]) >>> arr2 = arr.view() >>> arr[0] = 2 >>> arr2 <IntegerArray> [2, 2, 3] Length: 3, dtype: Int64