# doc-cache created by Octave 11.2.0
# name: cache
# type: cell
# rows: 3
# columns: 24
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
andrewsplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1524
statistics: andrewsplot ( x )
statistics: andrewsplot ( x , name , value , &hellip;)
statistics: andrewsplot ( ax , &hellip;)
statistics: h = andrewsplot (&hellip;)

Create an Andrews plot of the multivariate data in x .

andrewsplot ( x ) plots each observation (row) of the
n -by- p matrix x as a smooth curve defined by the finite
Fourier series

f_i(t) = x_i1/sqrt(2) + x_i2 sin(2*pi*t) + x_i3 cos(2*pi*t)
+ x_i4 sin(4*pi*t) + x_i5 cos(4*pi*t) + &hellip;

evaluated over t in the interval [0,1] , where x_ij is the
j -th variable of the i -th observation.

The following name/value pairs are accepted:

"Group"
A grouping variable (numeric, logical, character, string, or cell array of
strings) with one entry per row of x . Curves are colored by group.
"Standardize"
Controls how the columns of x are transformed before the curves are
computed: "off" (default) uses the raw data, "on" centers and
scales each column to zero mean and unit standard deviation, "PCA"
uses the principal component scores, and "PCAStd" uses the principal
component scores of the standardized data.
"Quantile"
A scalar alpha in the interval (0,1) . Instead of one curve per
observation, only three curves per group are drawn: the pointwise median and
the alpha and 1- alpha quantiles of the group&rsquo;s curves.

andrewsplot ( ax , &hellip;) plots into the axes ax .

The optional output h is a vector of handles to the plotted lines: one
per observation, or three per group when "Quantile" is used.

See also:
parallelcoords,
glyphplot,
pca


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Create an Andrews plot of the multivariate data in x.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
bar3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3699
statistics: bar3 ( z )
statistics: bar3 ( y , z )
statistics: bar3 (&hellip;, width )
statistics: bar3 (&hellip;, style )
statistics: bar3 (&hellip;, color )
statistics: bar3 (&hellip;, name , value )
statistics: bar3 ( ax , &hellip;)
statistics: p = bar3 (&hellip;)

Plot a 3D bar graph.

bar3 ( z ) plots 3D bar graph for the elements of z . Each
bar corresponds to an element in z , which can be a scalar, vector, or
2D matrix. By default, each column in z is considered as a series and
it is handled as a distinct series of bars. When z is a vector, unlike
MATLAB, which plots it as a single series of bars, Octave discriminates
between a row and column vector of z . Hence, when z is column
vector, it is plotted as a single series of bars (same color), whereas when
z is row vector, each bar is plotted as a different group (different
colors). For an M&times;N matrix, the function plots the bars corresponding
to each row on the y-axis ranging from 1 to M and each
column on the x-axis ranging from 1 to N .

bar3 ( y , z ) plots a 3D bar graph of the elements in
z at the y-values specified in y . It should be noted
that y only affects the tick names along the y-axis rather the
actual values. If you want to specify non-numerical values for y , you
can specify it with the paired name / value syntax shown below.

bar3 (&hellip;, width ) sets the width of the bars along the
x- and y-axes and controls the separation of bars among each
other. width can take any value in the range (0,1] . By default,
width is 0.8 and the bars have a small separation. If width is 1, the
bars touch one another. Alternatively, you can define width as a two-
element vector using the paired name / value syntax shown below, in
which case you can control the bar separation along each axis independently.

bar3 (&hellip;, style ) specifies the style of the bars, where
style can be 'detached' , 'grouped' , or
'stacked' . The default style is 'detached' .

bar3 (&hellip;, color ) displays all bars using the color
specified
by color. For example, use 'red' or 'r' to specify all red
bars. When you want to specify colors for several groups, color can be
a cellstr vector with each element specifying the color of each group.
color can also be specified as a numerical M&times;3 matrix, where
each row corresponds to a RGB value with its elements in the range
[0,1] . If only one color is specified, then it applies to all bars.
If the number of colors equals the number of groups, then each color is
applied to each group. If the number of colors equals the number of elements
in z , then each individual bar is assigned the particular color. You
can also define color using the paired name / value syntax
shown below.

bar3 (&hellip;, name , value ) specifies one or more of the
following name/value pairs:

Name Value
'width' A two-element vector specifying the width
of the bars along the x- and y-axes , respectively. Each
element must be in the range (0,1] .
'color' A character or a cellstr vector, or a
numerical M&times;3 matrix following the same conventions as the color
input argument.
'xlabel' A cellstr vector specifying the group names
along the x-axis .
'ylabel' A cellstr vector specifying the names of the
bars in the same series along the y-axis .

bar3 ( ax , &hellip;) can also take an axes handle ax as a
first argument in which case it plots into the axes specified by ax
instead of into the current axes specified by gca () . The optional
argument ax can precede any of the input argument combinations in the
previous syntaxes.

p = bar3 (&hellip;) returns a patch handle p , which can be
used to set properties of the bars after displaying the 3D bar graph.

See also:
boxplot,
hist3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
Plot a 3D bar graph.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
bar3h


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3726
statistics: bar3h ( y )
statistics: bar3h ( z , y )
statistics: bar3h (&hellip;, width )
statistics: bar3h (&hellip;, style )
statistics: bar3h (&hellip;, color )
statistics: bar3h (&hellip;, name , value )
statistics: bar3h ( ax , &hellip;)
statistics: p = bar3h (&hellip;)

Plot a horizontal 3D bar graph.

bar3h ( y ) plots 3D bar graph for the elements of y . Each
bar corresponds to an element in y , which can be a scalar, vector, or
2D matrix. By default, each column in y is considered as a series and
it is handled as a distinct series of bars. When y is a vector, unlike
MATLAB, which plots it as a single series of bars, Octave distinguishes
between a row and column vector of y . Hence, when y is column
vector, it is plotted as a single series of bars (same color), whereas when
y is row vector, each bar is plotted as a different group (different
colors). For an M&times;N matrix, the function plots the bars corresponding
to each row on the z-axis ranging from 1 to M and each
column on the x-axis ranging from 1 to N .

bar3h ( z , y ) plots a 3D bar graph of the elements in
y at the z-values specified in z . It should be noted
that z only affects the tick names along the z-axis rather the
actual values. If you want to specify non-numerical values for z , you
can specify it with the paired name / value syntax shown below.

bar3h (&hellip;, width ) sets the width of the bars along the
x- and z-axes and controls the separation of bars among each
other. width can take any value in the range (0,1] . By default,
width is 0.8 and the bars have a small separation. If width is 1, the
bars touch one another. Alternatively, you can define width as a two-
element vector using the paired name / value syntax shown below, in
which case you can control the bar separation along each axis independently.

bar3h (&hellip;, style ) specifies the style of the bars, where
style can be 'detached' , 'grouped' , or
'stacked' . The default style is 'detached' .

bar3h (&hellip;, color ) displays all bars using the color
specified by color. For example, use 'red' or 'r' to
specify all red bars. When you want to specify colors for several groups,
color can be a cellstr vector with each element specifying the color of
each group. color can also be specified as a numerical M&times;3
matrix, where each row corresponds to a RGB value with its elements in the
range [0,1] . If only one color is specified, then it applies to all
bars. If the number of colors equals the number of groups, then each color
is applied to each group. If the number of colors equals the number of
elements in y , then each individual bar is assigned the particular
color. You can also define color using the paired
name / value syntax shown below.

bar3h (&hellip;, name , value ) specifies one or more of the
following name/value pairs:

Name Value
'width' A two-element vector specifying the width
of the bars along the x- and z-axes , respectively. Each
element must be in the range (0,1] .
'color' A character or a cellstr vector, or a
numerical M&times;3 matrix following the same conventions as the color
input argument.
'xlabel' A cellstr vector specifying the group names
along the x-axis .
'zlabel' A cellstr vector specifying the names of the
bars in the same series along the z-axis .

bar3h ( ax , &hellip;) can also take an axes handle ax as a
first argument in which case it plots into the axes specified by ax
instead of into the current axes specified by gca () . The optional
argument ax can precede any of the input argument combinations in the
previous syntaxes.

p = bar3h (&hellip;) returns a patch handle p , which can be
used to set properties of the bars after displaying the 3D bar graph.

See also:
boxplot,
hist3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Plot a horizontal 3D bar graph.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
biplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1853
statistics: biplot ( coefs )
statistics: biplot ( coefs , name , value , &hellip;)
statistics: biplot ( ax , &hellip;)
statistics: h = biplot (&hellip;)

Create a biplot of the coefficients in coefs .

biplot ( coefs ) plots the rows of coefs , typically the
principal component coefficients returned by pca or pcacov or
the factor loadings returned by factoran , as vectors from the origin.
coefs has one row per observed variable and either two columns (for a
2-D biplot) or three columns (for a 3-D biplot).

The following name/value pairs are accepted:

"Scores"
A matrix of scores with the same number of columns as coefs (one row
per observation). The scores are plotted as points, scaled to fit within the
unit circle relative to the maximum coefficient length: each score is divided
by the maximum absolute score value and multiplied by the length of the
longest coefficient vector.
"VarLabels"
A character array or cell array of strings labeling each variable vector.
"ObsLabels"
A character array or cell array of strings labeling each observation.
"Positive"
If true , the reference axes are drawn only over the positive quadrant
(2-D) or octant (3-D). The default is false .

Any additional name/value pairs are treated as line properties and applied to
the variable vectors.

For readability the sign of each column of coefs is chosen so that its
largest-magnitude element is positive; the same sign change is applied to the
corresponding column of the scores.

biplot ( ax , &hellip;) plots into the axes ax .

The optional output h is a column vector of handles to the plotted
graphics objects, ordered as the variable vector lines, the variable markers,
the variable text labels (if any), the observation markers, the observation
text labels (if any), and finally the reference axis lines.

See also:
pca,
pcacov,
factoran,
rotatefactors


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Create a biplot of the coefficients in coefs.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
boxplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6499
statistics: s = boxplot ( data )
statistics: s = boxplot ( data , group )
statistics: s = boxplot ( data , notched , symbol , orientation , whisker , &hellip;)
statistics: s = boxplot ( data , group , notched , symbol , orientation , whisker , &hellip;)
statistics: s = boxplot ( data , options )
statistics: s = boxplot ( data , group , options , &hellip;)
statistics: [&hellip;, h ] = boxplot ( data , &hellip;)

Produce a box plot.

A box plot is a graphical display that simultaneously describes several
important features of a data set, such as center, spread, departure from
symmetry, and identification of observations that lie unusually far from
the bulk of the data.

Input arguments (case-insensitive) recognized by boxplot are:

data is a matrix with one column for each data set, or a cell vector
with one cell for each data set. Each cell must contain a numerical row or
column vector (NaN and NA are ignored) and not a nested vector of cells.

notched = 1 produces a notched-box plot. Notches represent a robust
estimate of the uncertainty about the median.
notched = 0 (default) produces a rectangular box plot.

notched within the interval (0,1) produces a notch of the specified
depth. Notched values outside (0,1) are amusing if not exactly impractical.

symbol sets the symbol for the outlier values. The default symbol
for points that lie outside 3 times the interquartile range is &rsquo;o&rsquo;;
the default symbol for points between 1.5 and 3 times the interquartile
range is &rsquo;+&rsquo;.
Alternative symbol settings:
symbol = &rsquo;.&rsquo;: points between 1.5 and 3 times the IQR are marked with
&rsquo;.&rsquo; and points outside 3 times IQR with &rsquo;o&rsquo;.

symbol = [&rsquo;x&rsquo;,&rsquo;*&rsquo;]: points between 1.5 and 3 times the IQR are marked
with &rsquo;x&rsquo; and points outside 3 times IQR with &rsquo;*&rsquo;.

orientation = 0 makes the boxes horizontally.
orientation = 1 plots the boxes vertically (default). Alternatively,
orientation can be passed as a string, e.g., &rsquo;vertical&rsquo; or &rsquo;horizontal&rsquo;.

whisker defines the length of the whiskers as a function of the IQR
(default = 1.5). If whisker = 0 then boxplot displays all data
values outside the box using the plotting symbol for points that lie
outside 3 times the IQR.

group may be passed as an optional argument only in the second
position after data . group can be a numeric, character,
string, or categorical vector defining separate categories. To group by
multiple variables simultaneously, pass a cell array of grouping vectors
(e.g., {group1, group2} ). A separate box is plotted for each
unique combination of group values. All grouping variables must have the
same length as data .

options are additional paired arguments passed with the formalism
(Name, Value) that provide extra functionality as listed below.
options can be passed at any order after the initial arguments and
are case-insensitive.

&rsquo;Notch&rsquo; &rsquo;on&rsquo; Notched by 0.25 of the boxes width.
&rsquo;off&rsquo; Produces a straight box.
scalar Proportional width of the notch.
&rsquo;Symbol&rsquo; &rsquo;.&rsquo; Defines only outliers between 1.5 and 3 IQR.
[&rsquo;x&rsquo;,&rsquo;*&rsquo;] 2nd character defines outliers > 3 IQR
&rsquo;Orientation&rsquo; &rsquo;vertical&rsquo; Default value, can also be defined
with numerical 1.
&rsquo;horizontal&rsquo; Can also be defined with numerical 0.
&rsquo;Whisker&rsquo; scalar Multiplier of IQR (default is 1.5).
&rsquo;OutlierTags&rsquo; &rsquo;on&rsquo; or 1 Plot the vector index of the outlier
value next to its point.
&rsquo;off&rsquo; or 0 No tags are plotted (default value).
&rsquo;Sample_IDs&rsquo; &rsquo;cell&rsquo; A cell vector with one cell for each
data set containing a nested cell vector with each sample&rsquo;s ID (should be
a string). If this option is passed, then all outliers are tagged with
their respective sample&rsquo;s ID string instead of their vector&rsquo;s index.
&rsquo;BoxWidth&rsquo; &rsquo;proportional&rsquo; Create boxes with their width
proportional to the number of samples in their respective dataset (default
value).
&rsquo;fixed&rsquo; Make all boxes with equal width.
&rsquo;Widths&rsquo; scalar Scaling factor for box widths (default
value is 0.4).
&rsquo;CapWidths&rsquo; scalar Scaling factor for whisker cap widths
(default value is 1, which results to &rsquo;Widths&rsquo;/8 halflength)
&rsquo;BoxStyle&rsquo; &rsquo;outline&rsquo; Draw boxes as outlines (default value).
&rsquo;filled&rsquo; Fill boxes with a color (outlines are still
plotted).
&rsquo;Positions&rsquo; vector Numerical vector that defines the
position of each data set. It must have the same length as the number of
groups in a desired manner. This vector merely defines the points along
the group axis, which by default is [1:number of groups].
&rsquo;Labels&rsquo; cell A cell vector of strings containing the names
of each group. By default each group is labeled numerically. If multiple
grouping variables are provided, default labels are automatically generated
by joining the category names and stacked hierarchically.
&rsquo;Colors&rsquo; character string or Nx3 numerical matrix If just
one character or 1x3 vector of RGB values, specify the fill color of all
boxes when BoxStyle = &rsquo;filled&rsquo;. If a character string or Nx3 matrix is
entered, box #1&rsquo;s fill color corresponds to the first character or first
matrix row, and the next boxes&rsquo; fill colors corresponds to the next
characters or rows. If the char string or Nx3 array is exhausted the color
selection wraps around.

Supplemental arguments not described above (&hellip;) are concatenated and
passed to the plot() function.

The returned matrix s has one column for each data set as follows:

1 Minimum
2 1st quartile
3 2nd quartile (median)
4 3rd quartile
5 Maximum
6 Lower confidence limit for median
7 Upper confidence limit for median

The quartiles are those of quantile at its default method, which is
also what prctile returns, so the box edges of a data set always
agree with prctile ( data , [25, 75]) . They set the
inter-quartile range, and so the whisker fences and which observations are
reported as outliers.

The returned structure h contains handles to the plot elements,
allowing customization of the visualization using set/get functions.

Example

title ("Grade 3 heights");
axis ([0,3]);
set(gca (), "xtick", [1 2], "xticklabel", {"girls", "boys"});
boxplot ({randn(10,1)*5+140, randn(13,1)*8+135});


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
Produce a box plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
cdfplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1047
statistics: hCDF = cdfplot ( x )
statistics: [ hCDF , stats ] = cdfplot ( x )

Display an empirical cumulative distribution function.

hCDF = cdfplot ( x ) plots an empirical cumulative
distribution function (CDF) of the observations in the data sample vector
x . x may be a row or column vector, and represents a random
sample of observations from some underlying distribution.

cdfplot plots F(x), the empirical (or sample) CDF versus the
observations in x . The empirical CDF, F(x), is defined as follows:

F(x) = (Number of observations <= x) / (Total number of observations)

for all values in the sample vector x . NaNs are ignored. hCDF
is the handle of the empirical CDF curve (a handle graphics &rsquo;line&rsquo; object).

[ hCDF , stats ] = cdfplot ( x ) also returns a structure
with the following fields as a statistical summary.

STATS.min minimum value of x
STATS.max maximum value of x
STATS.mean sample mean of x
STATS.median sample median (50th percentile) of x
STATS.std sample standard deviation of x

See also:
qqplot,
cdfcalc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Display an empirical cumulative distribution function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
dendrogram


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2000
statistics: dendrogram ( tree )
statistics: dendrogram ( tree , p )
statistics: dendrogram ( tree , prop , val )
statistics: dendrogram ( tree , p , prop , val )
statistics: h = dendrogram (&hellip;)
statistics: [ h , t , perm ] = dendrogram (&hellip;)

Plot a dendrogram of a hierarchical binary cluster tree.

Given tree , a hierarchical binary cluster tree as the output of
linkage , plot a dendrogram of the tree. The number of leaves shown by
the dendrogram plot is limited to p . The default value for p is
30. Set p to 0 to plot all leaves.

The optional outputs are h , t and perm :

h is a handle to the lines of the plot.
t is the vector with the numbers assigned to each leaf.
Each element of t is a leaf of tree and its value is the number
shown in the plot.
When the dendrogram plot is collapsed, that is when the number of shown
leaves p is inferior to the total number of leaves, a single leaf of
the plot can represent more than one leaf of tree : in that case
multiple elements of t share the same value, that is the same leaf of
the plot.
When the dendrogram plot is not collapsed, each leaf of the plot is the leaf
of tree with the same number.
perm is the vector list of the leaves as ordered as in the plot.

Additional input properties can be specified by pairs of properties and
values. Known properties are:

'Reorder'
Reorder the leaves of the dendrogram plot using a numerical vector of size n,
the number of leaves. When p is smaller than n , the reordering
cannot break the p groups of leaves.
'Orientation'
Change the orientation of the plot. Available values: top (default),
bottom , left , right .
'CheckCrossing'
Check if the lines of a reordered dendrogram cross each other. Available
values: true (default), false .
'ColorThreshold'
Not implemented.
'Labels'
Use a char, string or cellstr array of size n to set the label for each
leaf; the label is displayed only for nodes with just one leaf.

See also:
cluster,
clusterdata,
cophenet,
inconsistent,
linkage,
pdist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Plot a dendrogram of a hierarchical binary cluster tree.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
ecdfhist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1316
statistics: [ n , c ] = ecdfhist ( f , x )
statistics: [ n , c ] = ecdfhist ( f , x , m )
statistics: [ n , c ] = ecdfhist ( f , x , centers )
statistics: ecdfhist (&hellip;)
statistics: ecdfhist ( ax , &hellip;)

Create a histogram from the output of ecdf .

[ n , c ] = ecdfhist ( f , x ) takes the empirical
cumulative distribution function f evaluated at the points x , as
computed by ecdf , and returns the heights n of histogram bars
for 10 equally spaced bins together with their centers c . Unlike a
count histogram, the bar heights are normalized so that the area of the
histogram is equal to 1, giving an estimate of the probability density
function.

[ n , c ] = ecdfhist ( f , x , m ) uses m
equally spaced bins.

[ n , c ] = ecdfhist ( f , x , centers ) uses
bins with the specified centers, given as a vector of monotonically
increasing values.

ecdfhist (&hellip;) without output arguments plots the histogram.

ecdfhist ( ax , &hellip;) plots into the axes ax instead of
the current axes.

The probability mass assigned to each bin is the sum of the increments of the
empirical cdf, diff ( f ) , over the points x that fall
closest to the corresponding bin center; ties are assigned to the lower
center. Each bar height is that mass divided by the bin width.

See also:
ecdf,
cdfplot,
hist,
histogram


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Create a histogram from the output of ecdf.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
einstein


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1261
statistics: einstein ()
statistics: tiles = einstein ( a , b )
statistics: [ tiles , rhat ] = einstein ( a , b )
statistics: [ tiles , rhat , that ] = einstein ( a , b )
statistics: [ tiles , rhat , that , shat ] = einstein ( a , b )
statistics: [ tiles , rhat , that , shat , phat ] = einstein ( a , b )
statistics: [ tiles , rhat , that , shat , phat , fhat ] = einstein ( a , b )

Plots the tiling of the basic clusters of einstein tiles.

Scalars a and b define the shape of the einstein tile.
See Smith et al (2023) for details: https://arxiv.org/abs/2303.10798

tiles is a structure containing the coordinates of the einstein
tiles that are tiled on the plot. Each field contains the tile coordinates
of the corresponding clusters.

tiles .rhat contains the reflected einstein tiles
tiles .that contains the three-hat shells
tiles .shat contains the single-hat clusters
tiles .phat contains the paired-hat clusters
tiles .fhat contains the fylfot clusters

rhat contains the coordinates of the first reflected tile
that contains the coordinates of the first three-hat shell
shat contains the coordinates of the first single-hat cluster
phat contains the coordinates of the first paired-hat cluster
fhat contains the coordinates of the first fylfot cluster


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Plots the tiling of the basic clusters of einstein tiles.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
glyphplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1562
statistics: glyphplot ( x )
statistics: glyphplot ( x , name , value , &hellip;)
statistics: g = glyphplot (&hellip;)

Create a star (glyph) plot of the multivariate data in x .

glyphplot ( x ) draws each observation (row) of the
n -by- p matrix x as a star glyph, arranged on a grid. The
p spokes of each star radiate from its center at equally spaced angles,
with lengths proportional to the values of the p variables; the tips of
the spokes are joined to form the star perimeter.

The following name/value pairs are accepted:

"Glyph"
"star" (default) draws star glyphs. "face" (Chernoff faces)
is not currently supported.
"Standardize"
How the columns of x are scaled to spoke lengths: "column"
(default) scales each column to the range [0,1] , "matrix"
scales the whole matrix to [0,1] , "PCA" uses principal
component scores scaled to [0,1] , and "off" uses the values as
given. A spoke of relative length 0 is still drawn at 10% of the maximum
radius so that it remains visible.
"Grid"
A two-element vector [rows cols] specifying the layout of the glyphs.
The default is chosen automatically.
"Centers"
An n -by-2 matrix giving the center coordinates of the glyphs
explicitly, overriding "Grid" .
"Radius"
The maximum glyph radius (default 0.4).
"ObsLabels"
A character array or cell array of strings labeling the observations. The
default is the observation numbers.

The optional output g is an n -by-3 matrix of handles whose
columns hold, respectively, the star perimeters, the star spokes, and the
text labels.

See also:
andrewsplot,
parallelcoords


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Create a star (glyph) plot of the multivariate data in x.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
gplotmatrix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2644
statistics: gplotmatrix ( x , y , group )
statistics: gplotmatrix ( x , [], group )
statistics: gplotmatrix ( x , y , group , clr , sym , siz )
statistics: gplotmatrix (&hellip;, doleg , dispopt )
statistics: gplotmatrix (&hellip;, doleg , dispopt , xnam , ynam )
statistics: gplotmatrix ( parent , &hellip;)
statistics: [ h , ax , bigax ] = gplotmatrix (&hellip;)

Create a matrix of scatter plots grouped by a categorical variable.

gplotmatrix ( x , y , group ) creates a matrix of
scatter plots. Each subplot in the resulting figure is a scatter plot of a
column of x against a column of y . If x is n -by- p
and y is n -by- q , the resulting figure holds a
q -by- p grid of subplots; the subplot in row i and column
j plots x (:,j) on the horizontal axis against
y (:,i) on the vertical axis. Points are grouped and colored
according to group , which is a grouping variable (numeric, logical,
character, string, or cell array of strings) with one entry per row of
x .

gplotmatrix ( x , [], group ) is equivalent to
gplotmatrix ( x , x , group ) except that the diagonal of
the p -by- p grid is replaced by grouped histograms of the columns
of x .

The appearance of the plot is controlled by further positional arguments:

clr
Marker colors, given as a character vector of color specifiers (e.g.
"rgb" ) or as a matrix of RGB triplets, one row per group. Colors
cycle if fewer are supplied than there are groups.
sym
Marker symbols, given as a character vector (e.g. "o+x" ); defaults to
"." . Symbols cycle if fewer are supplied than there are groups.
siz
Marker sizes, given as a numeric vector. Sizes cycle if fewer are supplied
than there are groups.
doleg
Either "on" (default) to display a legend of the groups or
"off" to suppress it.
dispopt
Controls the diagonal of the grid when y is empty: "stairs"
(default) for grouped stairstep histograms, "hist" or
"grpbars" for grouped bar histograms, "none" to leave the
diagonal empty, or "variable" to write the variable names on the
diagonal.
xnam , ynam
Character vectors or cell arrays of strings giving the names of the columns of
x and y , used to label the outer axes.

An optional leading parent argument (a figure or uipanel handle) selects
the container for the plot.

The optional outputs are h , an array of handles to the plotted objects
with size ny -by- p -by- k (where ny is the number of rows
of the grid and k the number of groups); ax , the matrix of handles
to the subplot axes (with an extra row of hidden axes for the diagonal
histograms); and bigax , the handle to the invisible enclosing axes used
for titles and labels.

See also:
gscatter,
plotmatrix,
grpstats


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Create a matrix of scatter plots grouped by a categorical variable.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
gscatter


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1566
statistics: gscatter ( x , y , g )
statistics: gscatter ( x , y , g , clr , sym , siz )
statistics: gscatter (&hellip;, doleg , xnam , ynam )
statistics: h = gscatter (&hellip;)

Draw a scatter plot with grouped data.

gscatter is a utility function to draw a scatter plot of x and
y , according to the groups defined by g . Input x and
y are numeric vectors of the same size, while g is either a
vector of the same size as x or a character matrix with the same number
of rows as the size of x . As a vector g can be numeric, logical,
a character array, a string array (not implemented), a cell string or cell
array.

A number of optional inputs change the appearance of the plot:

"clr"
defines the color for each group; if not enough colors are defined by
"clr" , gscatter cycles through the specified colors. Colors can
be defined as named colors, as rgb triplets or as indices for the current
colormap . The default value is a different color for each group,
according to the current colormap .
"sym"
is a char array of symbols for each group; if not enough symbols are defined
by "sym" , gscatter cycles through the specified symbols.
"siz"
is a numeric array of sizes for each group; if not enough sizes are defined
by "siz" , gscatter cycles through the specified sizes.
"doleg"
is a boolean value to show the legend; it can be either on (default)
or off .
"xnam"
is a character array, the name for the x axis.
"ynam"
is a character array, the name for the y axis.

Output h is an array of graphics handles to the line object of
each group.

See also:
scatter


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Draw a scatter plot with grouped data.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
hist3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1879
statistics: hist3 ( X )
statistics: hist3 ( X , nbins )
statistics: hist3 ( X , "Nbins" , nbins )
statistics: hist3 ( X , centers )
statistics: hist3 ( X , "Ctrs" , centers )
statistics: hist3 ( X , "Edges" , edges )
statistics: [ N , C ] = hist3 (&hellip;)
statistics: hist3 (&hellip;, prop , val , &hellip;)
statistics: hist3 ( hax , &hellip;)

Produce bivariate (2D) histogram counts or plots.

The elements to produce the histogram are taken from the Nx2 matrix
X . Any row with NaN values are ignored. The actual bins can
be configured in 3 different: number, centers, or edges of the bins:

Number of bins (default)
Produces equally spaced bins between the minimum and maximum values
of X . Defined as a 2 element vector, nbins , one for each
dimension. Defaults to [10 10] .
Center of bins
Defined as a cell array of 2 monotonically increasing vectors,
centers . The width of each bin is determined from the adjacent
values in the vector with the initial and final bin, extending to Infinity.
Edge of bins
Defined as a cell array of 2 monotonically increasing vectors,
edges . N (i,j) contains the number of elements
in X for which:

edges {1}(i) <= X (:,1) < edges {1}(i+1)

edges {2}(j) <= X (:,2) < edges {2}(j+1)

The consequence of this definition is that values outside the initial
and final edge values are ignored, and that the final bin only contains
the number of elements exactly equal to the final edge.

The return values, N and C , are the bin counts and centers
respectively. These are specially useful to produce intensity maps:

[counts, centers] = hist3 (data);
imagesc (centers{1}, centers{2}, counts)

If there is no output argument, or if the axes graphics handle
hax is defined, the function will plot a 3 dimensional bar
graph. Any extra property/value pairs are passed directly to the
underlying surface object.

See also:
hist,
histc,
lookup,
mesh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Produce bivariate (2D) histogram counts or plots.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
histfit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1331
statistics: histfit ( x )
statistics: histfit ( x , nbins )
statistics: histfit ( x , nbins , distname )
statistics: histfit ( ax , &hellip;)
statistics: h = histfit (&hellip;)

Plot histogram with superimposed distribution fit.

histfit ( x ) plots a histogram of the values in the vector
x using the number of bins equal to the square root of the number of
non-missing elements in x and superimposes a fitted normal density
function.

histfit ( x , nbins ) plots a histogram of the values in the
vector x using nbins number of bins in the histogram and
superimposes a fitted normal density function.

histfit ( x , nbins , distname ) plots a histogram of
the values in the vector x using nbins number of bins in the
histogram and superimposes a fitted density function from the distribution
specified by distname .

histfit ( ax , &hellip;) uses the axes handle ax to plot the
histogram and the fitted density function onto followed by any of the input
argument combinations specified in the previous syntaxes.

h = histfit (&hellip;) returns a vector of handles h , where
h (1) is the handle to the histogram and h (2) is
the handle to the density curve.

Note: calling histfit without any input arguments will return a cell
array of character vectors listing all supported distributions.

See also:
bar,
hist,
normplot,
fitdist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Plot histogram with superimposed distribution fit.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
manovacluster


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 848
statistics: manovacluster ( stats )
statistics: manovacluster ( stats , method )
statistics: h = manovacluster ( stats )
statistics: h = manovacluster ( stats , method )

Cluster group means using manova1 output.

manovacluster ( stats ) draws a dendrogram showing the clustering
of group means, calculated using the output STATS structure from
manova1 and applying the single linkage algorithm. See the
dendrogram function for more information about the figure.

manovacluster ( stats , method ) uses the method
algorithm in place of single linkage. The available methods are:

"single" &mdash; nearest distance
"complete" &mdash; furthest distance
"average" &mdash; average distance
"centroid" &mdash; center of mass distance
"ward" &mdash; inner squared distance

h = manovacluster (&hellip;) returns a vector of line handles.

See also:
manova1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Cluster group means using manova1 output.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
normplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 690
statistics: normplot ( x )
statistics: normplot ( ax , x )
statistics: h = normplot (&hellip;)

Produce normal probability plot of the data in x . If x is a
matrix, normplot plots the data for each column. NaN values are
ignored.

h = normplot ( ax , x ) takes a handle ax in
addition to the data in x and it uses that axes for plotting. You may
get this handle of an existing plot with gca .

The line joining the 1st and 3rd quantile is drawn solid whereas its
extensions to both ends are dotted. If the underlying distribution is normal,
the points will cluster around the solid part of the line. Other distribution
types will introduce curvature in the plot.

See also:
cdfplot,
wblplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Produce normal probability plot of the data in x.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
parallelcoords


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1492
statistics: parallelcoords ( x )
statistics: parallelcoords ( x , name , value , &hellip;)
statistics: parallelcoords ( ax , &hellip;)
statistics: h = parallelcoords (&hellip;)

Create a parallel coordinates plot of the multivariate data in x .

parallelcoords ( x ) plots each observation (row) of the
n -by- p matrix x as a line connecting the values of its
p coordinates, which are placed at the equally spaced horizontal
positions 1, 2, &hellip;, p .

The following name/value pairs are accepted:

"Group"
A grouping variable (numeric, logical, character, string, or cell array of
strings) with one entry per row of x . Lines are colored by group.
"Standardize"
Controls how the columns of x are transformed before plotting:
"off" (default) uses the raw data, "on" centers and scales
each column to zero mean and unit standard deviation, "PCA" uses the
principal component scores, and "PCAStd" uses the principal component
scores of the standardized data.
"Quantile"
A scalar alpha in the interval (0,1) . Instead of one line per
observation, only three lines per group are drawn: the coordinate-wise median
and the alpha and 1- alpha quantiles of the group.
"Labels"
A character array or cell array of strings giving the tick labels for the
coordinate axis.

parallelcoords ( ax , &hellip;) plots into the axes ax .

The optional output h is a vector of handles to the plotted lines: one
per observation, or three per group when "Quantile" is used.

See also:
andrewsplot,
glyphplot,
pca


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Create a parallel coordinates plot of the multivariate data in x.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ppplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 890
statistics: ppplot ( x , dist )
statistics: ppplot ( x , dist , params )
statistics: [ p , y ] = ppplot ( x , dist , params )

Perform a PP-plot (probability plot).

If F is the CDF of the distribution dist with parameters
params and x a sample vector of length n , the PP-plot
graphs ordinate y ( i ) = F ( i -th largest element of
x ) versus abscissa p ( i ) = ( i - 0.5)/ n . If
the sample comes from F, the pairs will approximately follow a straight
line.

The default for dist is the standard normal distribution.

The optional argument params contains a list of parameters of
dist .

For example, for a probability plot of the uniform distribution on [2,4]
and x , use

ppplot (x, "unif", 2, 4)

dist can be any string for which a function distcdf that
calculates the CDF of distribution dist exists.

If no output is requested then the data are plotted immediately.

See also:
qqplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Perform a PP-plot (probability plot).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
probplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1998
statistics: probplot ( y )
statistics: probplot ( dist , y )
statistics: probplot ( dist , y , cens )
statistics: probplot ( dist , y , cens , freq )
statistics: probplot ( ax , &hellip;)
statistics: probplot (&hellip;, "noref" )
statistics: h = probplot (&hellip;)

Produce a probability plot of the data in y against the distribution
dist .

On a probability plot the ordered data are drawn against a nonlinear
probability axis chosen so that a sample from the reference distribution
dist falls approximately along a straight line. Systematic departures
from the reference line indicate departures from the distribution.

dist is one of "normal" (the default when dist is
omitted), "lognormal" , "exponential" , "extreme value" ,
"weibull" , "rayleigh" , "logistic" , or
"loglogistic" . For "lognormal" , "weibull" , and
"loglogistic" the data axis is logarithmic.

y is a numeric vector, or a matrix in which case each column is plotted
as a separate sample. NaN values are ignored.

cens is a logical vector the same size as y that is true for
right-censored observations; censored points are not plotted and the plotting
positions of the remaining points follow the Kaplan-Meier estimate. freq
is a vector of nonnegative integer frequencies (counts) the same size as
y . Pass [] to omit either one.

probplot ( ax , &hellip;) plots into the axes ax instead of
the current axes. The trailing option "noref" suppresses the
reference line.

h = probplot (&hellip;) returns a column vector of handles to the
plotted line objects (the data markers, followed by the reference line unless
"noref" was given).

The reference line is a robust fit through the first and third quartiles of the
data on the transformed scale. For censored data the quartiles are taken from
the Kaplan-Meier plotting positions; when heavy censoring prevents the data
from reaching a quartile the position is linearly extrapolated, which may
deviate slightly from MATLAB .

See also:
normplot,
wblplot,
qqplot,
cdfplot,
ecdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Produce a probability plot of the data in y against the distribution dist.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qqplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1127
statistics: [ q , s ] = qqplot ( x )
statistics: [ q , s ] = qqplot ( x , y )
statistics: [ q , s ] = qqplot ( x , dist )
statistics: [ q , s ] = qqplot ( x , y , params )
statistics: qqplot (&hellip;)

Perform a QQ-plot (quantile plot).

If F is the CDF of the distribution dist with parameters
params and G its inverse, and x a sample vector of length
n , the QQ-plot graphs ordinate s ( i ) = i -th
largest element of x versus abscissa q ( i f) = G(( i -
0.5)/ n ).

If the sample comes from F, except for a transformation of location
and scale, the pairs will approximately follow a straight line.

If the second argument is a vector y the empirical CDF of y
is used as dist .

The default for dist is the standard normal distribution. The
optional argument params contains a list of parameters of
dist . For example, for a quantile plot of the uniform
distribution on [2,4] and x , use

qqplot (x, "unif", 2, 4)

dist can be any string for which a function distinv or
dist_inv exists that calculates the inverse CDF of distribution
dist .

If no output arguments are given, the data are plotted directly.

See also:
ppplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Perform a QQ-plot (quantile plot).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
scatterhist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3438
statistics: scatterhist ( x , y )
statistics: scatterhist ( x , y , name , value , &hellip;)
statistics: h = scatterhist (&hellip;)

Create a scatter plot of x and y with marginal histograms.

scatterhist ( x , y ) draws a scatter plot of the vectors
x and y in a central set of axes, with a histogram of x
above it and a histogram of y to its right. x and y must
be vectors of the same length; NaN values are removed pairwise from
the scatter plot and individually from each marginal histogram.

The following name/value pairs are accepted:

"Group"
A grouping variable (numeric, logical, character, string, or cell array of
strings) with one entry per point. The scatter points and the marginal
histograms are separated and colored by group.
"NBins"
The number of bins for the marginal histograms, either a scalar applied to
both or a two-element vector [nx ny] . The default is chosen by Scott&rsquo;s
rule.
"Kernel"
"off" (default) draws histograms for the marginals; "on" or
"overlay" draws kernel density estimates instead.
"Location"
Corner occupied by the marginal plots, the scatter taking the opposite one:
"SouthWest" (default), "SouthEast" , "NorthEast" , or
"NorthWest" .
"Legend"
"on" or "off" to show or hide the group legend. The default
is "on" when a grouping variable is supplied.
"Marker" , "MarkerSize"
The marker symbol(s) and size(s) for the scatter points, cycled over the
groups.

The optional output h is a three-element vector of axes handles: the
central scatter axes, the axes of the x (horizontal) histogram, and the
axes of the y (vertical) histogram.

The y histogram&rsquo;s axes is built differently from MATLAB&rsquo;s and its
properties read accordingly. We plot that marginal transposed, so its
"XLim" is the density and "XDir" carries the bar direction.
MATLAB plots it like the x one &ndash; data along "XLim" , density
along "YLim" &ndash; and rotates the whole axes by setting
"View" to [270, 90] , so there the direction is carried by
"YDir" and "XDir" is always "normal" . The picture
is the same; code reading those properties off h (3) is not
portable between the two.

'Parent' draws into a supplied figure or uipanel instead of the
current figure. The container is used as it stands and is never
cleared, so a scatterhist can be placed alongside other axes.

'Location' names the corner the marginal histograms occupy,
'SouthWest' by default, or 'SouthEast' , 'NorthEast'
or 'NorthWest' ; the scatter takes the opposite corner. With the
default the histograms are drawn below and to the left of the scatter.

'Direction' points the marginal bars toward the scatter plot,
'in' by default, or away from it with 'out' , whichever side
'Location' has placed them on.

'PlotGroup' draws one marginal per group with 'on' , or a
single pooled marginal with 'off' . It defaults to 'on' when
'Group' is given and to 'off' otherwise.

'Style' outlines the marginals as 'bar' or 'stairs' ,
defaulting to stairs when the data are grouped and bars when they are not.

'Color' sets the group colours, either as a character vector of
colour names or as an N -by-3 matrix of RGB values, cycled over the
groups.

'LineStyle' and 'LineWidth' style the marginal outlines, not
the scatter markers, and are cycled over the groups.

'Bandwidth' sets the kernel bandwidth used when 'Kernel' is
on: a scalar for all marginals, a pair for x and y , or one row
per group.

See also:
gscatter,
scatter,
hist,
ksdensity


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Create a scatter plot of x and y with marginal histograms.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
silhouette


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1782
statistics: silhouette ( X , clust )
statistics: [ si , h ] = silhouette ( X , clust )
statistics: [ si , h ] = silhouette (&hellip;, Metric , MetricArg )

Compute the silhouette values of clustered data and show them on a plot.

X is a n-by-p matrix of n data points in a p-dimensional space. Each
datapoint is assigned to a cluster using clust , a vector of n elements,
one cluster assignment for each data point.

Each silhouette value of si , a vector of size n, is a measure of the
likelihood that a data point is accurately classified to the right cluster.
Defining "a" as the mean distance between a point and the other points from
its cluster, and "b" as the mean distance between that point and the points
from other clusters, the silhouette value of the i-th point is:

$$ S_i = \frac{b_i - a_i}{max(a_1,b_i)} $$

Each element of si ranges from -1, minimum likelihood of a correct
classification, to 1, maximum likelihood.

Optional input value Metric is the metric used to compute the distances
between data points. Since silhouette uses pdist to compute
these distances, Metric is similar to the Distance input argument
of pdist and it can be:

A known distance metric defined as a string: euclidean ,
squaredeuclidean (default), seuclidean , mahalanobis ,
cityblock , minkowski , chebychev , cosine ,
correlation , hamming , jaccard , or spearman .
A vector as those created by pdist . In this case X does
nothing.
A function handle that is passed to pdist with MetricArg
as optional inputs.

Optional return value h is a handle to the silhouette plot.

Reference
Peter J. Rousseeuw, Silhouettes: a Graphical Aid to the Interpretation and
Validation of Cluster Analysis. 1987. doi:10.1016/0377-0427(87)90125-7

See also:
dendrogram,
evalclusters,
kmeans,
linkage,
pdist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Compute the silhouette values of clustered data and show them on a plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
violin


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2324
statistics: violin ( x )
statistics: h = violin ( x )
statistics: h = violin (&hellip;, property , value , &hellip;)
statistics: h = violin ( hax , &hellip;)
statistics: h = violin (&hellip;, "horizontal" )

Produce a Violin plot of the data x .

The input data x can be a N-by-m array containing N observations of m
variables. It can also be a cell with m elements, for the case in which the
variables are not uniformly sampled.

The following property can be set using property / value
pairs (default values in parenthesis). The value of the property can be a
scalar indicating that it applies to all the variables in the data. It can
also be a cell/array, indicating the property for each variable. In this case
it should have m columns (as many as variables).

Color
("y") Indicates the filling color of the violins.
Nbins
(50) Internally, the function calls hist to compute the histogram
of the data. This property indicates how many bins to use.
See help hist for more details.
SmoothFactor
(4) The function performs simple kernel density estimation and automatically
finds the bandwidth of the kernel function that best approximates the
histogram using optimization ( sqp ).
The result is in general very noisy. To smooth the result the bandwidth is
multiplied by the value of this property. The higher the value the smoother
the violins, but values too high might remove features from the data
distribution.
Bandwidth
(NA) If this property is given a value other than NA, it sets the bandwidth
of the kernel function. No optimization is performed and the property
SmoothFactor is ignored.
Width
(0.5) Sets the maximum width of the violins. Violins are centered at integer
axis values. The distance between two violin middle axis is 1. Setting a
value higher than 1 in this property will cause the violins to overlap.

If the string "Horizontal" is among the input arguments, the violin
plot is rendered along the x axis with the variables in the y axis.

The returned structure h has handles to the plot elements, allowing
customization of the visualization using set/get functions.

Example:

title ("Grade 3 heights");
axis ([0,3]);
set (gca, "xtick", 1:2, "xticklabel", {"girls"; "boys"});
h = violin ({randn(100,1)*5+140, randn(130,1)*8+135}, "Nbins", 10);
set (h.violin, "linewidth", 2)

See also:
boxplot,
hist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Produce a Violin plot of the data x.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
wblplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1647
statistics: wblplot ( data , &hellip;)
statistics: handle = wblplot ( data , &hellip;)
statistics: [ handle , param ] = wblplot ( data )
statistics: [ handle , param ] = wblplot ( data , censor )
statistics: [ handle , param ] = wblplot ( data , censor , freq )
statistics: [ handle , param ] = wblplot ( data , censor , freq , confint )
statistics: [ handle , param ] = wblplot ( data , censor , freq , confint , fancygrid )
statistics: [ handle , param ] = wblplot ( data , censor , freq , confint , fancygrid , showlegend )

Plot a column vector data on a Weibull probability plot using rank
regression.

censor : optional parameter is a column vector of same size as
data with 1 for right censored data and 0 for exact observation.
Pass [] when no censor data are available.

freq : optional vector same size as data with the number of
occurrences for corresponding data.
Pass [] when no frequency data are available.

confint : optional confidence limits for plotting upper and lower
confidence bands using beta binomial confidence bounds. If a single
value is given this will be used such as LOW = a and HIGH = 1 - a.
Pass [] if confidence bounds is not requested.

fancygrid : optional parameter which if set to anything but 1 will turn
off the fancy gridlines.

showlegend : optional parameter that when set to zero(0) turns off the
legend.

If one output argument is given, a handle for the data marker and
plotlines is returned, which can be used for further modification of line and
marker style.

If a second output argument is specified, a param vector with scale,
shape and correlation factor is returned.

See also:
normplot,
wblpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Plot a column vector data on a Weibull probability plot using rank regression.





