FData#
- class skfda.representation.FData(*, extrapolation=None, dataset_name=None, argument_names=None, coordinate_names=None, sample_names=None)[source]#
Defines the structure of a functional data object.
- Attributes:
n_samples (int) – Number of samples.
dim_domain (int) – Dimension of the domain.
dim_codomain (int) – Dimension of the image.
extrapolation (Extrapolation) – Default extrapolation mode.
dataset_name (str) – name of the dataset.
argument_names (tuple) – tuple containing the names of the different arguments.
coordinate_names (tuple) – tuple containing the names of the different coordinate functions.
- Parameters:
extrapolation (Optional[ExtrapolationLike]) –
dataset_name (str | None) –
argument_names (Optional[LabelTupleLike]) –
coordinate_names (Optional[LabelTupleLike]) –
sample_names (Optional[LabelTupleLike]) –
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.
compose
(fd, *[, eval_points])Composition of functions.
concatenate
(*others[, as_coordinates])Join samples from a similar FData object.
copy
(*[, deep, dataset_name, ...])Make a copy of the object.
cov
()Compute the covariance of the functional data object.
delete
(loc)derivative
(*[, order])Differentiate a FData object.
dropna
()Return ExtensionArray without NA values.
duplicated
([keep])Return boolean ndarray denoting duplicate values.
equals
(other)Whole object equality.
evaluate
()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.
insert
(loc, item)Insert an item at the given position.
integrate
(*[, domain])Integration of the FData object.
interpolate
(*, method, axis, index, limit, ...)See DataFrame.interpolate.__doc__.
isin
(values)Pointwise comparison for set containment in the given values.
isna
()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 FDatGrid object.
ravel
([order])Return a flattened view on this array.
repeat
(repeats[, axis])Repeat elements of a ExtensionArray.
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
([grid_points])Return the discrete representation of the object.
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.
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])
- abstract compose(fd, *, eval_points=None)[source]#
Composition of functions.
Performs the composition of functions.
- abstract concatenate(*others, as_coordinates=False)[source]#
Join samples from a similar FData object.
Joins samples from another FData object if it has the same dimensions and has compatible representations.
- abstract copy(*, deep=False, dataset_name=None, argument_names=None, coordinate_names=None, sample_names=None, extrapolation=None)[source]#
Make a copy of the object.
- Parameters:
- Return type:
T
- abstract cov(s_points: ndarray[Any, dtype[float64]], t_points: ndarray[Any, dtype[float64]], /, correction: int = 0) ndarray[Any, dtype[float64]] [source]#
- abstract cov(correction: int = 0) Callable[[ndarray[Any, dtype[float64]], ndarray[Any, dtype[float64]]], ndarray[Any, dtype[float64]]]
Compute the covariance of the functional data object.
Calculates the unbiased sample covariance function of the data. This is expected to be only defined for univariate functions. The resulting covariance function is defined in the cartesian product of the domain of the functions. If s_points or t_points are not provided, this method returns a callable object representing the covariance function. If s_points and t_points are provided, this method returns the evaluation of the covariance function at the grid formed by the cartesian product of the points in s_points and t_points.
- Parameters:
s_points – Points where the covariance function is evaluated.
t_points – Points where the covariance function is evaluated.
correction – degrees of freedom adjustment. The divisor used in the calculation is N - correction, where N represents the number of elements. Default: 0.
- Returns:
Covariance function.
- delete(loc)#
- Parameters:
loc (PositionalIndexer) –
- Return type:
Self
- abstract derivative(*, order=1)[source]#
Differentiate a FData object.
- Parameters:
order (int) – Order of the derivative. Defaults to one.
self (T) –
- Returns:
Functional object containg the derivative.
- Return type:
T
- 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: ArrayLike, *, derivative: int = 0, extrapolation: Evaluator | Literal['bounds', 'exception', 'nan', 'none', 'periodic', 'zeros'] | None = None, grid: Literal[False] = False, aligned: Literal[True] = True) ndarray[Any, dtype[float64]] [source]#
- evaluate(eval_points: Iterable[ArrayLike], *, derivative: int = 0, extrapolation: Evaluator | Literal['bounds', 'exception', 'nan', 'none', 'periodic', 'zeros'] | None = None, grid: Literal[False] = False, aligned: Literal[False]) ndarray[Any, dtype[float64]]
- evaluate(eval_points: ArrayLike | Sequence[ArrayLike], *, derivative: int = 0, extrapolation: Evaluator | Literal['bounds', 'exception', 'nan', 'none', 'periodic', 'zeros'] | None = None, grid: Literal[True], aligned: Literal[True] = True) ndarray[Any, dtype[float64]]
- evaluate(eval_points: Iterable[ArrayLike | Sequence[ArrayLike]], *, derivative: int = 0, extrapolation: Evaluator | Literal['bounds', 'exception', 'nan', 'none', 'periodic', 'zeros'] | None = None, grid: Literal[True], aligned: Literal[False]) ndarray[Any, dtype[float64]]
Evaluate the object at a list of values or a grid.
Deprecated since version 0.8: Use normal calling notation instead.
- Parameters:
eval_points – 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 – Deprecated. Order of the derivative to evaluate.
extrapolation – 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 – 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 – 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.
- 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
- 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
- abstract integrate(*, domain=None)[source]#
Integration of the FData object.
The integration is performed over the whole domain. Thus, for a function of several variables this will be a multiple integral.
For a vector valued function the vector of integrals will be returned.
- 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
- abstract isna()[source]#
A 1-D array indicating if each value is missing.
- Returns:
In most cases, this should return a NumPy ndarray. For exceptional cases like
SparseArray
, where returning an ndarray would be expensive, an ExtensionArray may be returned.- Return type:
Notes
If returning an ExtensionArray, then
na_values._is_boolean
should be Truena_values should implement
ExtensionArray._reduce()
na_values.any
andna_values.all
should be implemented
Examples
>>> arr = pd.array([1, 2, np.nan, np.nan]) >>> arr.isna() array([False, False, True, True])
- 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']
- 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])
- abstract shift(shifts, *, restrict_domain=False, extrapolation=None, grid_points=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 (Union[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 (Optional[ExtrapolationLike]) – Controls the extrapolation mode for elements outside the domain range. By default uses the method defined in fd. See extrapolation to more information.
grid_points (Optional[GridPointsLike]) – Grid of points where the functions are evaluated to obtain the discrete representation of the object to operate. If
None
the current grid_points are used to unificate the domain of the shifted data.
- Returns:
Shifted functions.
- Return type:
- abstract sum(*, axis=None, out=None, keepdims=False, skipna=False, min_count=0)[source]#
Compute the sum of all the samples.
- Parameters:
axis (int | None) – 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:
A FData object with just one sample representing the sum of all the samples in the original object.
- 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
- abstract to_basis(basis, **kwargs)[source]#
Return the basis representation of the object.
- Parameters:
basis (Basis) – basis object in which the functional data are going to be represented.
kwargs (Any) – keyword arguments to be passed to FDataBasis.from_data().
- Returns:
Basis representation of the funtional data object.
- Return type:
- abstract to_grid(grid_points=None)[source]#
Return the discrete representation of the object.
- Parameters:
grid_points (Optional[GridPointsLike]) – Points per axis where the function is going to be evaluated.
- Returns:
Discrete representation of the functional data object.
- Return type:
- 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
- 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