Sample¶

class Sample(*args)¶

Sample of real vectors.

Available constructors:

Sample(array)

Sample(size, dim)

Sample(size, point)

Sample(other, first, last)

Parameters:

array2-d sequence of float: The data
sizeint, $m > 0$ , optional: The sample size. Default creates an empty sample with dimension 1.
dimensionint, $n \geq 0$ , optional: The real vectors dimension. Default creates an empty sample with dimension 1.
pointPoint or flat (1d) array, list or tuple of floats, optional: The point that will be repeated along the sample. Default creates a sample filled with zeros (null vectors).
otherSample: The sample contains points to copy.
firstint, $0 \leq first < m$: The index of the first point to copy.
lastint, $first < last \leq m$ , optional: The index after the last point to copy.

Methods

`BuildFromDataFrame`()	Convert a pandas DataFrame to Sample.
`BuildFromPoint`(point)	Static method for building a sample from a sequence of float.
`ImportFromCSVFile`(*args)	Static method for building a sample from a CSV file.
`ImportFromTextFile`(*args)	Static method for building a sample from a text file.
`add`(*args)	Append a sample (in-place).
`argsort`([isIncreasing])	Returns indices of sorted sample.
`asDataFrame`()	Convert to pandas DataFrame.
`asPoint`()	Accessor to the internal linear storage for 1D sample.
`clear`()	Erase all values.
`computeCentralMoment`(k)	Estimate componentwise central moments.
`computeCovariance`()	Estimate the covariance matrix.
`computeEmpiricalCDF`(point[, tail])	Estimate the empirical cumulative distribution function (ECDF).
`computeKendallTau`()	Estimate the Kendall coefficients matrix.
`computeKurtosis`()	Estimate the componentwise kurtosis (4th order central normalized moment).
`computeLinearCorrelation`()	Estimate the linear (Pearson) correlation matrix.
`computeMean`()	Estimate the mean vector.
`computeMedian`()	Estimate the componentwise medians (50%-quantiles).
`computeQuantile`(*args)	Estimate the quantile of the joint distribution underlying the sample.
`computeQuantilePerComponent`(*args)	Estimate the componentwise quantiles.
`computeRange`()	Compute the range per component.
`computeRawMoment`(k)	Compute the raw (non-central) moment per component.
`computeSkewness`()	Estimate the componentwise skewness (3rd order central normalized moment).
`computeSpearmanCorrelation`()	Estimate the Spearman correlation matrix.
`computeStandardDeviation`()	Estimate the componentwise standard deviations.
`computeVariance`()	Estimate the componentwise variances.
`erase`(*args)	Erase point(s) at or between index(es) (in-place).
`exportToCSVFile`(*args)	Dump the sample to a CSV file.
`find`(point)	Get the position of a point in the sample.
`getClassName`()	Accessor to the object's name.
`getDescription`()	Accessor to the componentwise description.
`getDimension`()	Accessor to the sample's dimension.
`getId`()	Accessor to the object's id.
`getImplementation`()	Accessor to the underlying implementation.
`getMarginal`(*args)	Accessor to sample marginal(s) (column(s)).
`getMax`()	Accessor to the componentwise maximum values.
`getMin`()	Accessor to the componentwise minimum values.
`getName`()	Accessor to the object's name.
`getSize`()	Accessor to the sample size.
`rank`(*args)	Compute the sample (componentwise) ranks.
`select`(indices)	Select points in a sample.
`setDescription`(description)	Accessor to the componentwise description.
`setName`(name)	Accessor to the object's name.
`sort`(*args)	Sort the sample.
`sortAccordingToAComponent`(index)	Sort the sample according to the given component.
`sortAccordingToAComponentInPlace`(index)	Sort the sample in place according to the given component.
`sortInPlace`()	Sort the sample in place.
`sortUnique`()	Sort the sample and remove duplicate points.
`sortUniqueInPlace`()	Sort the sample in place and remove duplicate points.
`split`(index)	Trunk the sample.
`stack`(sample)	Stack (horizontally) the given sample to the current one (in-place).

Examples

Create a Sample

>>> import openturns as ot
>>> import numpy as np
>>> sample = ot.Sample(3, 2)
>>> print(sample)
0 : [ 0 0 ]
1 : [ 0 0 ]
2 : [ 0 0 ]

Create a Sample from a (2d) array, list or tuple

>>> import numpy as np
>>> sample = ot.Sample(np.array([(1.0, 2.0), (3.0, 4.0), (5.0, 6.0)]))

and back

>>> z = np.array(sample)

Load a sample from a CSV file

>>> sample = ot.Sample.ImportFromCSVFile('sample.csv', ',')

Eventually samples may also be generated from probability distributions or experiments

>>> random_sample = ot.Normal(2).getSample(10)
>>> experiment = ot.LHSExperiment(ot.Normal(2), 10).generate()

Translation: addition or subtraction of a (compatible) sample or a point, or a scalar which is promoted into a point of compatible dimension with equal components

>>> print(sample + sample)
: [  2  4 ]
: [  6  8 ]
: [ 10 12 ]
>>> print(sample - sample)
: [ 0 0 ]
: [ 0 0 ]
: [ 0 0 ]
>>> print(sample - sample[0])
: [ 0 0 ]
: [ 2 2 ]
: [ 4 4 ]
>>> print(sample - sample[0, 0])
: [ 0 1 ]
: [ 2 3 ]
: [ 4 5 ]

__init__(*args)¶

BuildFromDataFrame()¶

Convert a pandas DataFrame to Sample.

Parameters:

dfpandas DataFrame: The data to convert

Returns:

sampleSample: The converted sample

static BuildFromPoint(point)¶

Static method for building a sample from a sequence of float.

Parameters:

data1d array-like: Data.

Returns:

sampleSample: Sample generated from sequence

Examples

>>> import openturns as ot
>>> n = 20
>>> x = ot.Sample.BuildFromPoint(range(n))
>>> data = [2.0, 2.0, 1.0, 1.0, 2.0, 3.0, 1.0, 2.0, 2.0, 1.0]
>>> sample = ot.Sample.BuildFromPoint(data)

static ImportFromCSVFile(*args)¶

Static method for building a sample from a CSV file.

Parameters:

file_namestr: Path to CSV file.
separatorstr, optional: Separating string. Default uses Sample-CSVFileSeparator from the ResourceMap.

Returns:

sampleSample: Sample loaded from the CSV file.

See also

exportToCSVFile, ImportFromTextFile

Notes

The file may or may not contain a header line (columns spanned with strings delimited with quotes). If it does contain such a header line, it will be used for setting the sample description using setDescription().

The implementation follows the RFC 4180: https://tools.ietf.org/html/rfc4180, for more permissive formats see ImportFromTextFile().

Examples

>>> import openturns as ot
>>> separator = ','
>>> sample = ot.Sample.ImportFromCSVFile('sample.csv', separator)

static ImportFromTextFile(*args)¶

Static method for building a sample from a text file.

Parameters:

file_namestr: Path to text file.
separatorstr, optional: Separating string. Default uses a blank space.
skipped_linesint, optional: Number of lines skipped. Default is 0.
decimalSeparatorstr, optional: Decimal separator. Default is dot.

Returns:

sampleSample: Sample loaded from the text file.

See also

ImportFromCSVFile

Notes

The file may or may not contain a header line (columns spanned with strings delimited with quotes). If it does contain such a header line, it will be used for setting the sample description using setDescription().

This method allows for more permissive file formatting than ImportFromCSVFile():

The field separator can be a whitespace
Comment lines or empty ones are allowed
Lines can be skipped from the start of the file

The comment marker is defined by the Sample-CommentsMarker entry from ResourceMap.

Examples

>>> import openturns as ot
>>> separator = ' '
>>> sample = ot.Sample.ImportFromTextFile('sample.txt', separator)

add(*args)¶

Append a sample (in-place).

Parameters:

point or samplesequence or 2-d sequence of float: The point(s) to append.

Examples

Append an existing sample with a single point.

>>> import openturns as ot
>>> sample = ot.Sample(3, 2)
>>> sample.add([1.0, 2.0])
>>> print(sample)
0 : [ 0 0 ]
1 : [ 0 0 ]
2 : [ 0 0 ]
3 : [ 1 2 ]

Append an existing sample with another sample.

>>> sample.add(ot.Sample(2, [2.0, 1.0]))
>>> print(sample)
: [ 0 0 ]
: [ 0 0 ]
: [ 0 0 ]
: [ 1 2 ]
: [ 2 1 ]
: [ 2 1 ]

argsort(isIncreasing=True)¶

Returns indices of sorted sample.

The algorithm sorts the points in the sample in the lexicographic order.

Returns:

indicesIndices: The indices which sorts the sample.
isIncreasingbool, optional: If True, sort in increasing order. If False, sort in decreasing order. Default is True.

Examples

>>> import openturns as ot
>>> sample = ot.Sample(
...     [[-1.0, 1.0, 0.0], [-1.0, 1.0, 1.0], [-1.0, 0.0, 1.0], [-1.0, 0.0, -1.0]]
... )
>>> print(sample)
0 : [ -1  1  0 ]
1 : [ -1  1  1 ]
2 : [ -1  0  1 ]
3 : [ -1  0 -1 ]
>>> indices = sample.argsort()
>>> print(indices)
[3,2,0,1]
>>> print(sample[indices])
    [ v0 v1 v2 ]
0 : [ -1  0 -1 ]
1 : [ -1  0  1 ]
2 : [ -1  1  0 ]
3 : [ -1  1  1 ]
>>> indices = sample.argsort(False)
>>> print(indices)
[1,0,2,3]

asDataFrame()¶

Convert to pandas DataFrame.

Returns:

dfpandas DataFrame: The converted data

asPoint()¶

Accessor to the internal linear storage for 1D sample.

Returns:

valuesPoint: Flat internal representation of the sample.

Notes

Available only for 1D sample.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal().getSample(5)
>>> print(sample)
    [ X0        ]
0 : [  0.608202 ]
1 : [ -1.26617  ]
2 : [ -0.438266 ]
3 : [  1.20548  ]
4 : [ -2.18139  ]
>>> print(sample.asPoint())
[0.608202,-1.26617,-0.438266,1.20548,-2.18139]

clear()¶: Erase all values.

computeCentralMoment(k)¶

Estimate componentwise central moments.

Parameters:

kint: The central moment’s order.

Returns:

mPoint: Componentwise central moment of order $k$ estimated from the sample.

Notes

The central moment of order $k$ is estimated as follows:

$\vect{\widehat{m}}^{(k)}_0 = \Tr{\left(\frac{1}{m} \sum_{j=1}^m \left(x_i^{(j)} - \widehat{\mu}_i\right)^k, \quad i = 1, \ldots, n\right)}$

where $\vect{\widehat{\mu}}$ is the estimator of the mean.

These estimators are the natural (possibly biased) estimators. For unbiased estimators use the other dedicated methods such as computeVariance() for the variance.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeCentralMoment(2))
[0.915126,0.873119]

computeCovariance()¶

Estimate the covariance matrix.

Returns:

covarianceCovarianceMatrix: Covariance matrix estimated from the sample.

Notes

The covariance matrix is estimated as follows:

$\mat{\widehat{\Sigma}} = \left[\frac{1}{m - 1} \sum_{k=1}^m \left(x_i^{(k)} - \widehat{\mu}_i\right) \left(x_j^{(k)} - \widehat{\mu}_j\right), \quad i, j = 1, \ldots, n\right]$

where $\vect{\widehat{\mu}}$ denotes the estimate of the mean.

This is an unbiased estimator.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeCovariance())
[[ 0.946682  0.0182104 ]
 [ 0.0182104 0.903226  ]]

computeEmpiricalCDF(point, tail=False)¶

Estimate the empirical cumulative distribution function (ECDF).

Parameters:

xsequence of float: CDF input.
survivalbool, optional: A flag telling whether this should estimate the empirical cumulative distribution function or the empirical survival function. Default is False and estimates the CDF.

Returns:

pfloat, $0 \leq p \leq 1$: Empirical CDF or SF value at point x.

Notes

The empirical cumulative distribution function (CDF) is estimated as follows:

$\hat{F}(\vect{x}) = \frac{1}{m} \sum_{j=1}^m \mathbf{1}_{\cap_{i=1}^n x_i^{(j)} \leq x_i}(\vect{x})$

The empirical survival function (SF) is estimated in a similar way:

$\hat{S}(\vect{x}) = \frac{1}{m} \sum_{j=1}^m \mathbf{1}_{\cap_{i=1}^n x_i^{(j)} > x_i}(\vect{x})$

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeEmpiricalCDF(sample[0]))
0.1

computeKendallTau()¶

Estimate the Kendall coefficients matrix.

Returns:

tauCorrelationMatrix: Kendall coefficients matrix estimated from the sample.

Notes

This uses an external implementation provided under the Boost Software License by David Simcha based on the paper by [knight1966]. It actually switches between two implementations depending on the sample size:

The most basic implementation performing in $O(m^2)$ is used when the sample size is less than SampleImplementation-SmallKendallTau from the ResourceMap.

The other more complex implementation performing in $O(m\log(m))$ is used for larger samples.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeKendallTau())
[[ 1          0.00689655 ]
 [ 0.00689655 1          ]]

computeKurtosis()¶

Estimate the componentwise kurtosis (4th order central normalized moment).

Returns:

kurtosisPoint: Componentwise kurtosis estimated from the sample.

Notes

The componentwise kurtosis are estimated as follows:

$\vect{\widehat{\kappa}} = \Tr{\left(\frac{m (m-1) (m+1)}{(m-2) (m-3)} \frac{\sum_{j=1}^m \left(x_i^{(j)} - \widehat{\mu}_i\right)^4} {\left(\sum_{j=1}^m \left(x_i^{(j)} - \widehat{\mu}_i\right)^2 \right)^2} - 3 \frac{3 (m-5)}{(m-2) (m-3)}, \quad i = 1, \ldots, n\right)}$

where $\vect{\widehat{\mu}}$ is the estimate of the mean.

This estimator is unbiased.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeKurtosis())
[3.27647,2.40275]

computeLinearCorrelation()¶

Estimate the linear (Pearson) correlation matrix.

Returns:

rhoCorrelationMatrix: Pearson correlation matrix estimated from the sample.

Notes

The Pearson correlation matrix is estimated as follows:

$\mat{\widehat{\rho}} = \left[\frac{\widehat{\Sigma}_{i,j}} {\widehat{\Sigma}_{i,i} \widehat{\Sigma}_{j,j}}, \quad i,j = 1, \ldots, n\right]$

where $\mat{\widehat{\Sigma}}$ denotes the estimate of the covariance.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeLinearCorrelation())
[[ 1         0.0196933 ]
 [ 0.0196933 1         ]]

computeMean()¶

Estimate the mean vector.

Returns:

meanPoint: Mean vector estimated from the sample.

Notes

The mean is estimated as follows:

$\vect{\widehat{\mu}} = \Tr{\left(\frac{1}{m} \sum_{j=1}^m x_i^{(j)}, \quad i = 1, \ldots, n\right)}$

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeMean())
[-0.0512622,0.136653]

computeMedian()¶

Estimate the componentwise medians (50%-quantiles).

Returns:

medianPoint: Median vector estimated from the sample.

See also

computeQuantilePerComponent

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeMedian())
[0.221141,0.108703]

computeQuantile(*args)¶

Estimate the quantile of the joint distribution underlying the sample.

Parameters:

pfloat, $0 \leq p \leq 1$ , or sequence of float: Input probability level.

Returns:

quantilePoint or Sample: Quantile of the joint distribution at probability level $p$ , estimated from the sample.

Raises:

NotImplementedYetErrorIf the dimension is greater than 1.

See also

computeQuantilePerComponent

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(1).getSample(30)
>>> print(sample.computeQuantile(.2))
[-0.947394]

computeQuantilePerComponent(*args)¶

Estimate the componentwise quantiles.

Parameters:

pfloat, $0 \leq p \leq 1$ , or sequence of float: Input probability level.

Returns:

quantilePoint or Sample: Componentwise quantile at probability level $p$ , estimated from the sample.

Notes

The present implementation interpolates the quantile between the two adjacent empirical quantiles ( $\widehat{x}_i^-$ and $\widehat{x}_i^+$ ):

$\widehat{q}_i = \alpha \widehat{x}_i^- + (1 - \alpha) \widehat{x}_i^+$

where $\alpha = p m - 0.5$ .

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeQuantilePerComponent(0.2))
[-0.696412,-0.767092]

computeRange()¶

Compute the range per component.

Returns:

rangePoint: Componentwise ranges estimated from the sample.

Notes

The statistical range is defined as the deviation between the maximal and the minimal value of the sample.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeRange())
[4.02827,3.49949]

computeRawMoment(k)¶

Compute the raw (non-central) moment per component.

Parameters:

kint, $k \geq 0$: Componentwise moment’s order.

Returns:

momentsPoint: Componentwise moments estimated from the sample.

Notes

The (raw) moment of order $k$ is estimated as follows:

$\vect{\widehat{m}}^{(k)} = \Tr{\left(\frac{1}{m} \sum_{j=1}^m {x_i^{(j)}}^k, \quad i = 1, \ldots, n\right)}$

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeRawMoment(2))
[0.917754,0.891793]

computeSkewness()¶

Estimate the componentwise skewness (3rd order central normalized moment).

Returns:

skewnessPoint: Componentwise skewness estimated from the sample.

Notes

The componentwise skewnesses are estimated as follows:

$\vect{\widehat{\delta}} = \Tr{\left(m \frac{\sqrt{m-1}}{m-2} \frac{\sum_{j=1}^m \left(x_i^{(j)} - \widehat{\mu}_i\right)^3} {\left(\sum_{j=1}^m \left(x_i^{(j)} - \widehat{\mu}_i\right)^2 \right)^{3/2}}, \quad i = 1, \ldots, n\right)}$

where $\vect{\widehat{\mu}}$ is the estimate of the mean.

This is an unbiased estimator.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeSkewness())
[-0.69393,0.231931]

computeSpearmanCorrelation()¶

Estimate the Spearman correlation matrix.

Returns:

rhoCorrelationMatrix: Spearman correlation matrix estimated from the sample.

See also

rank, computeLinearCorrelation

Notes

The Spearman correlation matrix is estimated as the Pearson correlation matrix of the ranks sample (i.e. using self.rank().computeLinearCorrelation()).

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeSpearmanCorrelation())
[[  1          -0.00556174 ]
 [ -0.00556174  1          ]]

computeStandardDeviation()¶

Estimate the componentwise standard deviations.

Returns:

standard_deviationsPoint: Componentwise standard deviation estimated from the sample.

See also

computeVariance

Notes

The componentwise standard deviations are estimated as the square root of the componentwise variances.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeStandardDeviation())
[0.972976,0.950382]

computeVariance()¶

Estimate the componentwise variances.

Returns:

variancesPoint: Componentwise variances estimated from the sample.

Notes

The componentwise variances are estimated as follows:

$\vect{\widehat{\sigma^2}} = \Tr{\left(\frac{1}{m-1} \sum_{j=1}^m \left(x_i^{(j)} - \widehat{\mu}_i\right)^2, \quad i = 1, \ldots, n\right)}$

where $\vect{\widehat{\mu}}$ is the estimate of the mean.

This estimator is unbiased.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.computeVariance())
[0.946682,0.903226]

erase(*args)¶

Erase point(s) at or between index(es) (in-place).

Parameters:

fint, $0 \leq f < m$: The index of the first point to erase.
lint, $f < l \leq m$ , optional: The index after the last point to erase. Default uses l = f + 1 and only removes sample[f].

Examples

>>> import openturns as ot
>>> sample = ot.Sample([[i] for i in range(5)])
>>> print(sample)
0 : [ 0 ]
1 : [ 1 ]
2 : [ 2 ]
3 : [ 3 ]
4 : [ 4 ]
>>> sample.erase(1, 3)
>>> print(sample)
0 : [ 0 ]
1 : [ 3 ]
2 : [ 4 ]

exportToCSVFile(*args)¶

Dump the sample to a CSV file.

Parameters:

file_namestr

Path to CSV file.

separatorstr, optional

Separating string. Default uses Sample-CSVFileSeparator from the ResourceMap.

decimalSeparatorstr, optional

Decimal separator. Default is dot.

precisionint, optional

Numerical precision Default takes Sample-CSVPrecision entry from ResourceMap.

formatstr, optional

Floating-point formatting, one of:

scientific: exponent notation
fixed: constant number of digits
defaultfloat: variable number of digits

Default takes Sample-CSVFormat entry from ResourceMap.

See also

ImportFromCSVFile, ImportFromTextFile

Notes

This will create a header line with componentwise descriptions (obtained from getDescription()) between quotes as column names. In scientific formatting the number of significant digits is $precision + 1$ .

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> sample.exportToCSVFile('sample.csv', '; ')

find(point)¶

Get the position of a point in the sample.

Parameters:

pointsequence of float: The wanted point.

Returns:

indexint,: Returns $m$ if the point does not belong to the sample.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(30)
>>> print(sample.find(sample[10]))
10
>>> print(sample.find([0.0, 0.0]))
30

getClassName()¶

Accessor to the object’s name.

Returns:

class_namestr: The object class name (object.__class__.__name__).

getDescription()¶

Accessor to the componentwise description.

Returns:

descriptionDescription: Description of the sample’s components.

See also

setDescription

getDimension()¶

Accessor to the sample’s dimension.

Returns:

nint: The number of components of the points in the sample.

getId()¶

Accessor to the object’s id.

Returns:

idint: Internal unique identifier.

getImplementation()¶

Accessor to the underlying implementation.

Returns:

implImplementation: A copy of the underlying implementation object.

getMarginal(*args)¶

Accessor to sample marginal(s) (column(s)).

Parameters:

indicesint, sequence of int, $0 \leq i < n$ or sequence of str: The identifiers of the wanted marginal(s). When the description contains duplicate labels, the first marginal is picked up.

Returns:

sampleSample: A subsample of the present sample with the requested marginal(s).

Notes

The Sample also implements slicing in its __getitem__ method.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(10).getSample(3)
>>> print(sample.getMarginal([1, 4]))
    [ X1        X4        ]
0 : [ -1.26617  -2.18139  ]
1 : [  0.261018 -1.31178  ]
2 : [  0.445785  0.473617 ]

getMax()¶

Accessor to the componentwise maximum values.

Returns:

maximum_valuesPoint: Componentwise maximum values.

getMin()¶

Accessor to the componentwise minimum values.

Returns:

minimum_valuesPoint: Componentwise minimum values.

getName()¶

Accessor to the object’s name.

Returns:

namestr: The name of the object.

getSize()¶

Accessor to the sample size.

Returns:

mint: The number points in the sample.

rank(*args)¶

Compute the sample (componentwise) ranks.

Parameters:

marginal_indexint, $0 \leq i < n$ , optional: The component whose ranks are wanted. Default computes the ranks of all the components.

Returns:

ranksSample: The requested ranks.

Notes

The ranks of a 1d sample is a list of indices that sorts the points in the ascending order. Ties (equal points) are averaged.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(3)
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
1 : [ -0.438266  1.20548  ]
2 : [ -2.18139   0.350042 ]
>>> print(sample.rank())
    [ X0 X1 ]
0 : [ 2  0  ]
1 : [ 1  2  ]
2 : [ 0  1  ]

select(indices)¶

Select points in a sample.

It selects the points at given locations and returns them as a new sample.

Parameters:

indicessequence of int, $0 \leq i < m$: The selected indices.

Returns:

selected_sampleSample: The selected points as a sample.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(3)
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
1 : [ -0.438266  1.20548  ]
2 : [ -2.18139   0.350042 ]
>>> selected_sample = sample.select([1, 0, 1])
>>> print(selected_sample)
    [ X0        X1        ]
0 : [ -0.438266  1.20548  ]
1 : [  0.608202 -1.26617  ]
2 : [ -0.438266  1.20548  ]

setDescription(description)¶

Accessor to the componentwise description.

Parameters:

descriptionsequence of str: Description of the sample’s components.

See also

getDescription

setName(name)¶

Accessor to the object’s name.

Parameters:

namestr: The name of the object.

sort(*args)¶

Sort the sample.

The ordering is based on the comparison operator of the Point. Hence, the sort method orders the points in the sample according to lexicographic order.

Parameters:

marginal_indexint, $0 \leq i < n$ , optional: The index of the component to sort. Default sorts the whole sample, i.e. the returned sorted sample has the same dimension as the input sample. If marginal_index is provided, then the returned sorted sample has dimension 1: the corresponding marginal sample is sorted and returned.

Returns:

sorted_sampleSample: The requested sorted sample.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(3)
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
1 : [ -0.438266  1.20548  ]
2 : [ -2.18139   0.350042 ]
>>> print(sample.sort())
    [ X0        X1        ]
0 : [ -2.18139   0.350042 ]
1 : [ -0.438266  1.20548  ]
2 : [  0.608202 -1.26617  ]
>>> print(sample.sort(1))
0 : [ -1.26617  ]
1 : [  0.350042 ]
2 : [  1.20548  ]

In the following sample, the first component of all points is equal to -1, which creates a tie where the other components must be used to make a difference in the comparison. The algorithm sorts the points taking into account all the components in the points. This shows that the algorithm uses lexicographic ordering, since using only the first component would leave the sample unchanged.

>>> import openturns as ot
>>> sample = ot.Sample(
...     [[-1.0, 1.0, 1.0], [-1.0, 1.0, 0.0], [-1.0, 0.0, 1.0], [-1.0, 0.0, -1.0]]
... )
>>> print(sample)
0 : [ -1  1  1 ]
1 : [ -1  1  0 ]
2 : [ -1  0  1 ]
3 : [ -1  0 -1 ]
>>> print(sample.sort())
0 : [ -1  0 -1 ]
1 : [ -1  0  1 ]
2 : [ -1  1  0 ]
3 : [ -1  1  1 ]

sortAccordingToAComponent(index)¶

Sort the sample according to the given component.

Parameters:

marginal_indexint, $0 \leq i < n$: The component to use for sorting the sample.

Returns:

sorted_sampleSample: The sample sorted according to the given component.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(3)
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
1 : [ -0.438266  1.20548  ]
2 : [ -2.18139   0.350042 ]
>>> print(sample.sortAccordingToAComponent(0))
    [ X0        X1        ]
0 : [ -2.18139   0.350042 ]
1 : [ -0.438266  1.20548  ]
2 : [  0.608202 -1.26617  ]

sortAccordingToAComponentInPlace(index)¶

Sort the sample in place according to the given component.

Parameters:

marginal_indexint, $0 \leq i < n$: The component to use for sorting the sample.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(3)
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
1 : [ -0.438266  1.20548  ]
2 : [ -2.18139   0.350042 ]
>>> sample.sortAccordingToAComponentInPlace(0)
>>> print(sample)
    [ X0        X1        ]
0 : [ -2.18139   0.350042 ]
1 : [ -0.438266  1.20548  ]
2 : [  0.608202 -1.26617  ]

sortInPlace()¶

Sort the sample in place.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(3)
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
1 : [ -0.438266  1.20548  ]
2 : [ -2.18139   0.350042 ]
>>> sample.sortInPlace()
>>> print(sample)
    [ X0        X1        ]
0 : [ -2.18139   0.350042 ]
1 : [ -0.438266  1.20548  ]
2 : [  0.608202 -1.26617  ]

sortUnique()¶

Sort the sample and remove duplicate points.

Returns:

unique_sampleSample: The requested sorted sample with duplicate points removed.

Examples

>>> import openturns as ot
>>> sample = ot.Sample([[3, 0, 3], [1, 1, 0], [0, 2, 2], [1, 1, 0]])
>>> print(sample)
0 : [ 3 0 3 ]
1 : [ 1 1 0 ]
2 : [ 0 2 2 ]
3 : [ 1 1 0 ]
>>> print(sample.sortUnique())
0 : [ 0 2 2 ]
1 : [ 1 1 0 ]
2 : [ 3 0 3 ]

sortUniqueInPlace()¶

Sort the sample in place and remove duplicate points.

Examples

>>> import openturns as ot
>>> sample = ot.Sample([[3, 0, 3], [1, 1, 0], [0, 2, 2], [1, 1, 0]])
>>> print(sample)
0 : [ 3 0 3 ]
1 : [ 1 1 0 ]
2 : [ 0 2 2 ]
3 : [ 1 1 0 ]
>>> sample.sortUniqueInPlace()
>>> print(sample)
0 : [ 0 2 2 ]
1 : [ 1 1 0 ]
2 : [ 3 0 3 ]

split(index)¶

Trunk the sample.

It splits the sample before the index passed as argument and returns the remainder as new sample.

Parameters:

indexint, $0 \leq i < m$: The truncation index.

Returns:

remainder_sampleSample: The remainder sample (everything that comes after the truncation index).

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(3)
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
1 : [ -0.438266  1.20548  ]
2 : [ -2.18139   0.350042 ]
>>> remainder_sample = sample.split(1)
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
>>> print(remainder_sample)
    [ X0        X1        ]
0 : [ -0.438266  1.20548  ]
1 : [ -2.18139   0.350042 ]

stack(sample)¶

Stack (horizontally) the given sample to the current one (in-place).

Parameters:

sampleSample: Sample to stack with compatible size.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> sample = ot.Normal(2).getSample(3)
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
1 : [ -0.438266  1.20548  ]
2 : [ -2.18139   0.350042 ]
>>> another_sample = ot.Normal(2).getSample(3)
>>> print(another_sample)
    [ X0        X1        ]
0 : [ -0.355007  1.43725  ]
1 : [  0.810668  0.793156 ]
2 : [ -0.470526  0.261018 ]
>>> sample.stack(another_sample)
>>> print(sample)
    [ X0        X1        X0        X1        ]
0 : [  0.608202 -1.26617  -0.355007  1.43725  ]
1 : [ -0.438266  1.20548   0.810668  0.793156 ]
2 : [ -2.18139   0.350042 -0.470526  0.261018 ]