# doc-cache created by Octave 11.3.0
# name: cache
# type: cell
# rows: 3
# columns: 49
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
NaT


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1241
 -- datatypes: T = NaT (N)
 -- datatypes: T = NaT (SZ1, ..., SZN)
 -- datatypes: T = NaT (SZ)
 -- datatypes: T = NaT (..., 'Format', FMT)
 -- datatypes: T = NaT (..., 'TimeZone', TZ)

     “Not-a-Time”.  Creates missing-valued datetime arrays.

     ‘T = NaT (N)’ creates an N*N datetime matrix with all values being
     Not-a-Time (NaT). When called with no size input values, it returns a NaT
     datetime scalar.

     ‘T = NaT (SZ1, ..., SZN)’ returns a datetime array with NaT values sized
     according to the input arguments SZ1, ..., SZN.  Alternatively, individual
     input size arguments can be merged into a single size vector SZ, as in the
     following syntax ‘T = NaT (SZ)’.

     ‘T = NaT (..., 'Format', FMT)’ returns a datetime array of NaT values with
     the specified display format.

     ‘T = NaT (..., 'TimeZone', TZ)’ returns a datetime array of NaT values in
     the time zone specified by TZ.

     NaT is the datetime equivalent of NaN. It represents a missing or invalid
     value.  NaT values never compare equal to, greater than, or less than any
     value, including other NaTs.  Doing arithmetic with a NaT and any other
     value results in a NaT.

     See also: datetime.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
“Not-a-Time”.  Cr



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1794
 -- datatypes: TBL = array2table (A)
 -- datatypes: TBL = array2table (A, NAME, VALUE)

     Convert an array to a table.

     ‘TBL = array2table (A)’ converts the 2-D matrix A to the table TBL, where
     each column of A becomes a variable in TBL.

     A can be any type of array supported by ‘table’, including a cell array, as
     long they are constraint to 2 dimensions.  However, in the case of a cell
     array ‘array2table’ does not extract the contents of its cells, resulting
     to a table with each variable being a column of cells.  Use ‘cell2table’ if
     you want to create a table from the contents of the cells in A.

     ‘TBL = array2table (A, NAME, VALUE)’ specifies optional parameters for
     creating the table TBL with the following Name-Value paired arguments.

     NAME               VALUE
                        
     --------------------------------------------------------------------------------
     'VariableNames'    A cell array of character vectors or a string array
                        defining the variable names of TBL.  The names must be
                        valid variable names and unique.
                        
     'RowNames'         A cell array of character vectors or a string array
                        defining the row names of TBL.  The names must be unique
                        but not necessarily valid variable names.
                        
     'DimensionNames'   A cell array of character vectors or a string array
                        defining the dimension names of TBL.  The names must be
                        unique and not in conflict with variable names.  By
                        default, dimension names are 'Row', 'Variables'.

     See also: cell2table, struct2table, table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
Convert an array to a table.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 491
 -- datatypes: CALD = caldays (X)

     Calendar duration in days.

     ‘CALD = caldays (X)’ returns a calendarDuration array representing calendar
     days equivalent to the values in X, which must be a numeric array of
     integer values.

     ‘caldays’ is also available as a method for calendarDuration arrays, in
     which case it performs the opposite conversion.

     See also: calendarDuration, calyears, calquarters, calmonths, calweeks,
     calendarDuration.caldays.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Calendar duration in days.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
calendarDuration


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 971
 -- datatypes: calendarDuration

     Array representing durations of time using flexible-length calendar
     date/time units.

     Each ‘calendarDuration’ element stores internally the number of whole
     months, the number of whole days, and a ‘duration’ object representing
     hours, minutes, and seconds.  It can be used to simplify calculations on
     ‘datetime’ arrays involving calendar units.

     ‘calendarDuration’ arrays can be created through their constructor by
     combining numeric arrays representing individual calendar duration units or
     through the functions ‘caldays’, ‘calweeks’, ‘calmonths’, ‘calquarters’,
     and ‘calyears’, which create calendar durations in terms of a single
     calendar duration unit.  These functions are also available as methods of
     ‘calendarDuration’ arrays to extract individual calendar duration units as
     numeric arrays.

     See also: datetime, duration.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Array representing durations of time using flexible-length calendar date/time...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 501
 -- datatypes: CALD = calmonths (X)

     Calendar duration in months.

     ‘CALD = calmonths (X)’ returns a calendarDuration array representing
     calendar months equivalent to the values in X, which must be a numeric
     array of integer values.

     ‘calmonths’ is also available as a method for calendarDuration arrays, in
     which case it performs the opposite conversion.

     See also: calendarDuration, calyears, calquarters, calweeks, caldays,
     calendarDuration.calmonths.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
Calendar duration in months.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 511
 -- datatypes: CALD = calquarters (X)

     Calendar duration in quarters.

     ‘CALD = calquarters (X)’ returns a calendarDuration array representing
     calendar quarters equivalent to the values in X, which must be a numeric
     array of integer values.

     ‘calquarters’ is also available as a method for calendarDuration arrays, in
     which case it performs the opposite conversion.

     See also: calendarDuration, calyears, calmonths, calweeks, caldays,
     calendarDuration.calquarters.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Calendar duration in quarters.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 496
 -- datatypes: CALD = calweeks (X)

     Calendar duration in weeks.

     ‘CALD = calweeks (X)’ returns a calendarDuration array representing
     calendar weeks equivalent to the values in X, which must be a numeric array
     of integer values.

     ‘calweeks’ is also available as a method for calendarDuration arrays, in
     which case it performs the opposite conversion.

     See also: calendarDuration, calyears, calquarters, calmonths, caldays,
     calendarDuration.calweeks.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
Calendar duration in weeks.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 496
 -- datatypes: CALD = calyears (X)

     Calendar duration in years.

     ‘CALD = calyears (X)’ returns a calendarDuration array representing
     calendar years equivalent to the values in X, which must be a numeric array
     of integer values.

     ‘calyears’ is also available as a method for calendarDuration arrays, in
     which case it performs the opposite conversion.

     See also: calendarDuration, calquarters, calmonths, calweeks, caldays,
     calendarDuration.calyears.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
Calendar duration in years.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1052
 -- datatypes: categorical

     Array representing categorical data.

     A ‘categorical’ array represents an array of values that correspond to a
     finite set of discrete categories, which can be either ordinal (having a
     mathematical ordering) or nominal.  It is an efficient way to define groups
     of rows in a table or to other types of variables.

     Each ‘categorical’ array stores the list of categories as a cell array of
     character vectors and a numeric array of uint16 type as indices to the
     categories.  The categorical array may also store elements of undefined
     categorical values, which represent the absence of a given category and
     correspond to the NaN value for numeric arrays or in general to the missing
     value for other data types.

     ‘categorical’ arrays do not have any public properties, which can be
     indexed by using dot notation similarly to structures.  However, there are
     several methods which can be used to modify their categories once they are
     constructed.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Array representing categorical data.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1674
 -- datatypes: TBL = cell2table (C)
 -- datatypes: TBL = cell2table (C, NAME, VALUE)

     Convert a cell array to a table.

     ‘TBL = cell2table (C)’ converts the 2-D cell array C to the table TBL,
     where the contents of each column of C becomes a variable in TBL.  The
     contents of each column are concatenated into their common data type (i.e.
     if a column of C contains explicitly double numbers, then the corresponding
     variable in TBL is of the same type), otherwise they are added as a column
     of cells.

     ‘TBL = cell2table (C, NAME, VALUE)’ specifies optional parameters for
     creating the table TBL with the following Name-Value paired arguments.

     NAME               VALUE
                        
     --------------------------------------------------------------------------------
     'VariableNames'    A cell array of character vectors or a string array
                        defining the variable names of TBL.  The names must be
                        valid variable names and unique.
                        
     'RowNames'         A cell array of character vectors or a string array
                        defining the row names of TBL.  The names must be unique
                        but not necessarily valid variable names.
                        
     'DimensionNames'   A cell array of character vectors or a string array
                        defining the dimension names of TBL.  The names must be
                        unique and not in conflict with variable names.  By
                        default, dimension names are 'Row', 'Variables'.

     See also: array2table, struct2table, table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Convert a cell array to a table.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
convertCharsToStrings


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 761
 -- datatypes: B = convertCharsToStrings (A)
 -- datatypes: [B1, ..., BN] = convertCharsToStrings (A1, ..., AN)

     Convert character arrays to a string arrays, where applicable.

     ‘B = convertCharsToStrings (A)’ converts A to a string scalar, if A is a
     character vector or array, or to a string array, if A is a cell array of
     character vectors.  Otherwise, A is returned unaltered.

     ‘[B1, ..., BN] = convertCharsToStrings (A1, ..., AN)’ converts any of the
     input arguments that are either character arrays or cell arrays of
     character vectors to string scalars or string arrays, respectively.
     Otherwise, ‘convertCharsToStrings’ returns the input arguments unaltered.

     See also: convertStringsToChars, string.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Convert character arrays to a string arrays, where applicable.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
convertStringsToChars


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 660
 -- datatypes: B = convertStringsToChars (A)
 -- datatypes: [B1, ..., BN] = convertStringsToChars (A1, ..., AN)

     Convert string arrays to a character arrays, where applicable.

     ‘B = convertStringsToChars (A)’ converts A to a character vector, if A is a
     string scalar, or to a cell array of character vectors, if A is a string
     array.  Otherwise, A is returned unaltered.

     ‘[B1, ..., BN] = convertStringsToChars (A1, ..., AN)’ converts any of the
     input arguments that are of string type to character vectors or to cell
     array of character vectors, or leaves them unaltered.

     See also: convertCharsToStrings, string.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Convert string arrays to a character arrays, where applicable.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11419
 -- datatypes: TBL = csv2table (FILENAME)
 -- datatypes: TBL = csv2table (FILENAME, NAME, VALUE)

     Load a CSV file into a table.

     ‘TBL = csv2table (FILENAME)’ creates a table TBL by reading the data in CSV
     file specified by FILENAME, which can be either character vector or a
     string scalar.  If the CSV file was saved by the ‘table2csv’ method, then
     it reads the custom comment line in the first element of the CSV file and
     reconstructs the table as specified including variable types, variable
     names, and possibly any nested tables or structures it may contain.  If no
     such special comment is found, then it treats the CSV file as simple
     columnar data and loads with the following default options.

       1. The first column is considered as RowNames and it is converted to cell
          array of character vectors and it is subsequently removed from the
          remaining data contained in the CSV file.  To change the default
          behavior, you need to specify the ReadRowNames and RowNamesColumn
          paired arguments accordingly.
       2. The first line is treated as a header containing the variable names of
          the table.  Any numeric values in the header line are converted to
          character vectors and all variable names are automatically modified to
          valid Octave variable names.  To change the default behavior, you need
          to specify the ReadVariableNames, VariableNamingRule, and
          VariableNamesLine paired arguments accordingly.
       3. The data type of each column in the remaining data is automatically
          detected according to its contents.  Consequently, text is converted
          to character vectors, datetime and duration strings are converted to
          datetime and duration arrays, respectively, and hexadecimal strings
          are converted to the smallest integer type that can represent all
          variable values.  To change the default behavior, you need to specify
          the TextType, DatetimeType, DurationType, and HexType accordingly.

     ‘TBL = csv2table (FILENAME, NAME, VALUE)’ specifies optional parameters for
     creating the table TBL with the following Name-Value paired arguments.

     NAME                       VALUE
                                
     --------------------------------------------------------------------------------
     'NumHeaderLines'           A positive integer scalar value specifying the
                                number of rows to omit reading from the CSV file.
                                If the CSV contains the custom comment line in its
                                first element, then the 'NumHeaderLines' applies
                                to the top number of rows to remove from the
                                created table.  If CSV is a generic case, then
                                'NumHeaderLines' specifies the number of lines to
                                omit parsing from the CSV file itself.
                                
     'VariableNames'            A cell array of character vectors or a string
                                array specifying the names of the variables of the
                                created table.  The names must be unique but not
                                necessarily valid variable names.  If not empty,
                                it overrides any variable names extracted from the
                                CSV file.  This applies both to custom and generic
                                CSV files.
                                
     'ReadVariableNames'        A logical scalar specifying whether to parse or
                                not the CSV files for variable names.  If your CSV
                                file only contains data, set 'ReadVariableNames'
                                to false so that ‘csv2table’ parses all lines as
                                data rows in the returned table.  Variable names
                                will be automatically generated to the default
                                style as done by ‘table’, unless otherwise
                                specified by the 'VariableNames' paired argument.
                                The default value is true.
                                
     'VariableNamingRule'       A character vector or a string scalar specifying
                                whether the variable names should be modified to
                                valid Octave variable names or the original names
                                should be preserved.  Valid options are "modify"
                                and "preserve".  By default, ‘csv2table’ modifies
                                the parsed variable names.
                                
     'VariableNamesLine'        A nonnegative integer scalar value specifying the
                                line number in the CSV file, which should be
                                parsed for variable names.  This only applies if
                                the 'ReadVariableNames' option is true.  The
                                specified line is subsequently removed from the
                                remaining data contained in the CSV file.  If
                                'VariableNamesLine' is set to zero, then it is
                                equivalent to setting 'ReadVariableNames' to
                                false.
                                
     'VariableTypes'            A cell array of character vectors or a string
                                array specifying the data type of the variables of
                                the created table.  The number of elements must
                                much the number of variable in the table.  This
                                optional argument only has an effect on generic
                                CSV files.  When specified, it overrides any other
                                data type specification or automatic detection by
                                the ‘csv2table’ function.
                                
     'VariableUnitsLine'        A nonnegative integer scalar value specifying the
                                line number in the CSV file, which should be
                                parsed for variable units.  The specified line is
                                subsequently removed from the remaining data
                                contained in the CSV file.
                                
     'VariableDescriptionsLine' A nonnegative integer scalar value specifying the
                                line number in the CSV file, which should be
                                parsed for variable descriptions.  The specified
                                line is subsequently removed from the remaining
                                data contained in the CSV file.
                                
     'ReadRowNames'             A logical scalar specifying whether to parse or
                                not the CSV files for row names.  If your CSV file
                                only contains data, set 'ReadRowNames' to false so
                                that ‘csv2table’ parses all columns as data
                                columms in the returned table.  The default value
                                is true.
                                
     'RowNamesColumn'           A nonnegative integer scalar value specifying the
                                column number in the CSV file, which should be
                                parsed for row names.  This only applies if the
                                'ReadRowNames' option is true.  The specified
                                column is subsequently removed from the remaining
                                data contained in the CSV file.  If
                                'RowNamesColumn' is set to zero, then it is
                                equivalent to setting 'ReadRowNames' to false.
                                Note that the values in the column specified by
                                'RowNamesColumn' must be unique, otherwise
                                ‘csv2table’ will return an error.
                                
     'TextType'                 A character vector or a string scalar specifying
                                whether the text data in the CSV file should be
                                stored in the table as character vectors or string
                                arrays.  Valid options are "char" and "string".
                                By default, ‘csv2table’ stores text data as
                                character vectors.
                                
     'DatetimeType'             A character vector or a string scalar specifying
                                whether the datetime strings found in the CSV file
                                should be stored in the table as datetime arrays
                                or as text data.  Valid options are "datetime" and
                                "text".  By default, ‘csv2table’ stores datetime
                                strings as datetime arrays.  If "text" is
                                specified, then the data type depends on the
                                'TextType' option.
                                
     'DurationType'             A character vector or a string scalar specifying
                                whether the duration strings found in the CSV file
                                should be stored in the table as duration arrays
                                or as text data.  Valid options are "duration" and
                                "text".  By default, ‘csv2table’ stores duration
                                strings as duration arrays.  If "text" is
                                specified, then the data type depends on the
                                'TextType' option.
                                
     'HexType'                  A character vector or a string scalar specifying
                                whether the hexadecimal text found in the CSV file
                                should be stored as a suitable integer type,
                                "auto" (default), as unaltered input text, "text",
                                (in which case the data type depends on the
                                'TextType' option), or as any of the integer types
                                supported by Octave.  Valid options are "auto",
                                "text", "int8", "int16", "int32", "int64",
                                "uint8", "uint16", "uint32", and "uint64".

     The following round-trip limitations apply when reading a file written by
     ‘table2csv’: ‘calendarDuration’ and ‘categorical’ variables are returned as
     cell arrays of character vectors (their values are not reconstructed),
     missing ‘string’ values are read back as empty strings, and datetime and
     duration display formats are not preserved, although the values themselves
     are exact.

     See also: array2table, struct2table, table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
Load a CSV file into a table.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1362
 -- datatypes: datetime

     Array representing points in time using the Gregorian calendar.

     A datetime array stores internally the datetime points as double arrays
     representing whole years, months, days, hours, and minutes, as well as
     seconds including their fractional part.  The underlying implementation
     relies on the 'date.h' C++ library.  The precision of this implementation
     is set at microseconds, which is substantial for typical times.

     A ‘datetime’ array is a collection of date/time elements, with each element
     holding a complete date/time.  The ‘datetime’ array also has TimeZone and
     Format properties associated with it, which apply to all elements in the
     array.

     When a display ‘Format’ contains a time-zone name field (z/zz/zzz), the
     name is rendered according to a session-wide style set by
     ‘datetime.zoneNameStyle’.  The default, 'iana', is an Octave-specific
     extension that shows the IANA abbreviation for every zone (e.g.  EEST);
     'matlab' restores MATLAB's behaviour of naming only North American zones
     and showing a numeric UTC+3-style offset elsewhere.  A single ‘Format’ may
     override the session style with zzzz (force 'iana') or zzzzz (force
     'matlab').  See ‘datetime.zoneNameStyle’.

     See also: calendarDuration, duration.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Array representing points in time using the Gregorian calendar.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 433
 -- datatypes: D = days (X)

     Fixed-time duration in days.

     ‘D = days (X)’ returns a duration array representing fixed-time duration
     days equivalent to the values in X, which must be a numeric array.

     ‘days’ is also available as a method for duration arrays, in which case it
     performs the opposite conversion.

     See also: duration, years, hours, minutes, seconds, milliseconds,
     duration.days.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
Fixed-time duration in days.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2893
 -- datatypes: BIN = discretize (X, EDGES)
 -- datatypes: BIN = discretize (X, N)
 -- datatypes: Y = discretize (..., VALUES)
 -- datatypes: C = discretize (..., 'categorical')
 -- datatypes: C = discretize (..., 'categorical', NAMES)
 -- datatypes: Y = discretize (..., 'IncludedEdge', SIDE)
 -- datatypes: [BIN, EDGES] = discretize (...)

     Group data into bins or categories.

     ‘BIN = discretize (X, EDGES)’ returns an array of the same size as X whose
     elements give the index of the bin that each value of X falls into.  EDGES
     must be a real numeric or logical vector of monotonically non-decreasing
     values, and defines ‘numel (EDGES) - 1’ bins.  Bin j covers the half-open
     interval ‘[EDGES(j), EDGES(j+1))’, except the last bin, which is closed at
     both ends.  Values outside ‘[EDGES(1), EDGES(end)]’, and any NaN, return
     NaN. BIN is always of type double.

     Repeated edges are permitted and meaningful: they define empty bins, which
     are simply never selected.  ‘discretize ([1, 2, 3], [1, 2, 2, 3])’ returns
     ‘[1, 3, 3]’.

     ‘BIN = discretize (X, N)’ uses N bins of uniform width spanning the range
     of X, where N is a positive integer scalar.  The edges are placed at "nice"
     decimal positions rather than exactly at ‘min (X)’ and ‘max (X)’, so the
     bins generally extend slightly beyond the data.  NaN and infinite values
     are ignored when determining the range.  This syntax is not available when
     X is of an integer type; supply explicit edges instead.

     ‘Y = discretize (..., VALUES)’ returns the corresponding element of VALUES
     in place of the bin index, so VALUES must be a vector whose length equals
     the number of bins.  Y takes the type of VALUES.  Elements of X that fall
     in no bin return NaN when VALUES is a floating-point array, zero when it is
     of an integer type, and raise an error when it is a cell array.

     ‘C = discretize (..., 'categorical')’ returns an ordinal categorical array
     whose categories are named after the bin intervals, for example '[1, 3)'.
     ‘C = discretize (..., 'categorical', NAMES)’ names the categories
     explicitly; NAMES must be a cell array of character vectors or a string
     vector whose length equals the number of bins.

     ‘Y = discretize (..., 'IncludedEdge', SIDE)’ selects which end of each bin
     is closed.  SIDE may be 'left' (the default, giving ‘[EDGES(j),
     EDGES(j+1))’ with the last bin closed at both ends) or 'right' (giving
     ‘(EDGES(j), EDGES(j+1)]’ with the first bin closed at both ends).

     ‘[BIN, EDGES] = discretize (...)’ also returns the bin edges used.  When
     the edges were supplied they are returned unchanged; when a bin count was
     requested they are returned as a row vector.

     See also: histcounts, categorical.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Group data into bins or categories.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 927
 -- datatypes: duration

     Array representing durations of time using fixed-length time units.

     duration values are stored internally as double type array representing
     numbers of elapsed days as a fixed-length time unit.  By default,
     fractional seconds of duration values are not displayed, but their actual
     precision is closer to nanoseconds for typical time lengths.

     ‘duration’ arrays can be created through their constructor by combining
     numeric arrays representing individual fixed-length elapsed time units or
     through the functions ‘years’, ‘days’, ‘hours’, ‘minutes’, ‘seconds’, and
     ‘calyears’, which create fixed-length durations in terms of a single
     duration units.  These functions are also available as methods of
     ‘duration’ arrays to extract individual duration units as numeric arrays.

     See also: calendarDuration, datetime.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Array representing durations of time using fixed-length time units.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1498
 -- datatypes: G = findgroups (A)
 -- datatypes: G = findgroups (A1, ..., AN)
 -- datatypes: [G, ID] = findgroups (A)
 -- datatypes: [G, ID1, ..., IDN] = findgroups (A1, ..., AN)

     Find groups defined by one or more grouping variables.

     ‘G = findgroups (A)’ returns G, a column vector of positive integer group
     numbers with one element per element of the grouping variable A.  The
     groups are the sorted unique values of A: if N groups are found, every
     integer between 1 and N labels a group.  Elements of A that are missing
     (‘NaN’, ‘NaT’, ‘<missing>’, ‘''’, or ‘<undefined>’) are labelled ‘NaN’ in
     G.  A can be a numeric, logical, ‘string’, ‘cellstr’, ‘char’, ‘datetime’,
     ‘duration’, ‘calendarDuration’, or ‘categorical’ vector.

     ‘G = findgroups (A1, ..., AN)’ defines groups as the sorted unique
     combinations of values across the grouping variables A1, ..., AN, which
     must all have the same number of elements.

     ‘[G, ID] = findgroups (A)’ also returns ID, the sorted unique values of A
     that identify each group.  With multiple grouping variables, ‘[G, ID1, ...,
     IDN] = findgroups (A1, ..., AN)’ returns one identifier vector per grouping
     variable.

     To group the variables of a ‘table’, call ‘findgroups (T)’, which
     dispatches to the ‘table’ method and returns the group identifiers as a
     table.

     See also: splitapply, table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Find groups defined by one or more grouping variables.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2086
 -- datatypes: B = groupcounts (A)
 -- datatypes: B = groupcounts (A, GROUPBINS)
 -- datatypes: [B, BG, BP] = groupcounts (...)
 -- datatypes: [...] = groupcounts (..., NAME, VALUE)

     Count the number of elements in each group of an array.

     ‘B = groupcounts (A)’ groups the rows of A by their values and returns B, a
     column vector with the number of elements in each group.  A is a grouping
     vector, a matrix whose columns are grouping variables, or a cell array of
     grouping vectors.  Groups are the sorted unique combinations of grouping
     values; rows holding a missing value in a grouping variable form their own
     groups, sorted after the non-missing groups.

     ‘[B, BG, BP] = groupcounts (...)’ also returns BG, the grouping values that
     identify each group, and BP, a column vector giving each group's count as a
     percentage of the total.  When A is a single grouping vector, BG holds its
     representative value for each group; when several grouping variables are
     given, BG is a cell array with one element per grouping variable.

     The optional GROUPBINS argument bins the grouping variables before grouping
     (a vector of bin edges or a positive integer number of bins, applied to a
     numeric, datetime, or duration grouping variable, or a cell array with one
     scheme per grouping variable); each binned variable becomes a categorical
     of bin interval labels.

     The behaviour can be modified with the 'IncludeMissingGroups' (default
     ‘true’), 'IncludeEmptyGroups' (default ‘false’), and 'IncludedEdge'
     (default 'left', the inclusive bin edge) NAME/VALUE pairs, as for the
     ‘table’ method.  When 'IncludeEmptyGroups' is ‘true’, the unused categories
     of a categorical or binned grouping variable contribute empty groups.

     To count the rows in each group of a ‘table’, call ‘groupcounts (T,
     GROUPVARS, ...)’, which dispatches to the ‘table’ method and returns the
     result as a table.

     See also: groupsummary, findgroups, splitapply, table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Count the number of elements in each group of an array.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2000
 -- datatypes: B = groupfilter (A, GROUPVARS, METHOD)
 -- datatypes: B = groupfilter (A, GROUPVARS, GROUPBINS, METHOD)
 -- datatypes: [B, BG] = groupfilter (...)

     Filter the rows of an array by a per-group condition.

     ‘B = groupfilter (A, GROUPVARS, METHOD)’ groups the rows of the array A by
     the grouping variables GROUPVARS, applies the filter function METHOD to
     each group, and returns B, the rows of A that satisfy the condition, in
     their original order.  GROUPVARS is a grouping vector with one element per
     row of A, or a cell array of such vectors.  Rows holding a missing value in
     a grouping variable form their own groups, to which METHOD is applied like
     any other group.

     METHOD is a function handle applied to each group's slice of every column
     of A.  It must return either a logical scalar, which keeps or drops the
     whole group, or a logical vector with one element per row of the group,
     which keeps or drops the individual rows.  A row is kept only when the
     condition holds for it across all columns of A.

     ‘[B, BG] = groupfilter (...)’ also returns BG, the grouping values of the
     kept rows.  When GROUPVARS is a single grouping vector, BG is a column
     vector with one element per kept row; when several grouping variables are
     given, BG is a cell array with one element per grouping variable.

     The optional GROUPBINS argument bins the grouping variables before grouping
     (a vector of bin edges or a positive integer number of bins, or a cell
     array with one scheme per grouping variable); see ‘groupsummary’ for
     details.  The 'IncludedEdge' Name-Value pair ('left' by default, or
     'right') selects which bin edge is inclusive.

     To filter the rows of a ‘table’, call ‘groupfilter (T, GROUPVARS, ...)’,
     which dispatches to the ‘table’ method and returns the result as a table.

     See also: groupsummary, groupcounts, findgroups, splitapply, table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Filter the rows of an array by a per-group condition.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
groupsummary


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2649
 -- datatypes: B = groupsummary (A, GROUPVARS, METHOD)
 -- datatypes: B = groupsummary (A, GROUPVARS, GROUPBINS, METHOD)
 -- datatypes: [B, BG, BC] = groupsummary (...)

     Compute summary statistics by group for an array.

     ‘B = groupsummary (A, GROUPVARS, METHOD)’ groups the rows of the array A by
     the grouping variables GROUPVARS and applies METHOD to each column of A
     within each group, returning the results in B, which has one row per group.
     GROUPVARS is a grouping vector with one element per row of A, or a cell
     array of such vectors.  Groups are the sorted unique combinations of
     grouping values; rows holding a missing value in a grouping variable form
     their own groups, sorted after the non-missing groups.

     METHOD is one of the names 'sum', 'mean', 'median', 'mode', 'var', 'std',
     'min', 'max', 'range', 'nnz', 'nummissing', or 'numunique', a function
     handle, or a cell array of method names andor function handles.  ‘NaN’
     values are omitted for every named method except 'nummissing'; a function
     handle receives the values with ‘NaN’ included and must return a single
     row.  When several methods are requested the columns of B are ordered by
     column of A first, then by method.

     ‘[B, BG, BC] = groupsummary (...)’ also returns BG, the grouping values
     that identify each group, and BC, a column vector with the number of rows
     in each group.  When GROUPVARS is a single grouping vector, BG holds its
     representative value for each group; when several grouping variables are
     given, BG is a cell array with one element per grouping variable.

     The optional GROUPBINS argument bins the grouping variables before
     grouping: a vector of bin edges or a positive integer number of equal-width
     bins, applied to a numeric, datetime, or duration grouping variable, or a
     cell array with one scheme per grouping variable.  Each binned variable
     becomes a categorical of bin interval labels.

     The behaviour can be modified with the 'IncludeMissingGroups' (default
     ‘true’), 'IncludeEmptyGroups' (default ‘false’), and 'IncludedEdge'
     (default 'left', the inclusive bin edge) NAME/VALUE pairs, as for the
     ‘table’ method.  When 'IncludeEmptyGroups' is ‘true’, the unused categories
     of a categorical or binned grouping variable contribute empty groups.

     To summarise the variables of a ‘table’, call ‘groupsummary (T, GROUPVARS,
     ...)’, which dispatches to the ‘table’ method and returns the result as a
     table.

     See also: findgroups, splitapply, table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Compute summary statistics by group for an array.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2644
 -- datatypes: B = grouptransform (A, GROUPVARS, METHOD)
 -- datatypes: B = grouptransform (A, GROUPVARS, GROUPBINS, METHOD)
 -- datatypes: [B, BG] = grouptransform (...)
 -- datatypes: [...] = grouptransform (..., NAME, VALUE)

     Transform the columns of an array group by group.

     ‘B = grouptransform (A, GROUPVARS, METHOD)’ groups the rows of the array A
     by the grouping variables GROUPVARS, applies METHOD to each column of A
     within each group, and returns B, the transformed values, one row per row
     of A and in the original order.  GROUPVARS is a grouping vector with one
     element per row of A, or a cell array of such vectors.  Rows holding a
     missing value in a grouping variable form their own groups, which are
     transformed like any other group.

     METHOD is one of the names 'zscore', 'norm', 'meancenter', 'rescale',
     'meanfill', 'linearfill', or a function handle.  'zscore' centers and
     scales each group to zero mean and unit standard deviation; 'norm' divides
     by the group 2-norm; 'meancenter' subtracts the group mean; 'rescale'
     rescales to the range ‘[0, 1]’; 'meanfill' replaces missing values with the
     group mean; and 'linearfill' fills missing values by linear interpolation
     within the group (leaving leading and trailing missing values unchanged).
     For the named methods ‘NaN’ values are omitted when computing the group
     statistics.  A function handle is applied to each group's column slice and
     must return either a single row (broadcast) or one row per row of the
     group.

     ‘[B, BG] = grouptransform (...)’ also returns BG, the grouping values of
     each row.  When GROUPVARS is a single grouping vector, BG is that vector;
     when several grouping variables are given, BG is a cell array with one
     element per grouping variable.

     The 'ReplaceValues' NAME/VALUE pair (default ‘true’) controls whether the
     transformed values replace the columns of A or, when ‘false’, are appended
     to them.  The optional GROUPBINS argument bins the grouping variables
     before grouping (a vector of bin edges or a positive integer number of
     bins, or a cell array with one scheme per grouping variable); see
     ‘groupsummary’ for details.  The 'IncludedEdge' pair ('left' by default, or
     'right') selects the inclusive bin edge.

     To transform the variables of a ‘table’, call ‘grouptransform (T,
     GROUPVARS, ...)’, which dispatches to the ‘table’ method and returns the
     result as a table.

     See also: groupsummary, groupfilter, findgroups, splitapply, table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Transform the columns of an array group by group.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2983
 -- datatypes: N = histcounts (X)
 -- datatypes: N = histcounts (X, NBINS)
 -- datatypes: N = histcounts (X, EDGES)
 -- datatypes: N = histcounts (..., NAME, VALUE)
 -- datatypes: [N, EDGES] = histcounts (...)
 -- datatypes: [N, EDGES, BIN] = histcounts (...)

     Histogram bin counts.

     ‘N = histcounts (X)’ partitions the values of X into bins chosen
     automatically and returns the number of elements in each bin as a row
     vector.  X is treated as ‘X(:)’ regardless of its shape, and NaN and
     infinite values are excluded.

     ‘N = histcounts (X, NBINS)’ uses NBINS bins, and ‘N = histcounts (X,
     EDGES)’ uses the bin edges given in the monotonically non-decreasing vector
     EDGES.  Bin j covers ‘[EDGES(j), EDGES(j+1))’, except the last bin, which
     is closed at both ends.

     ‘[N, EDGES, BIN] = histcounts (...)’ also returns the bin edges and, in
     BIN, the index of the bin each element of X belongs to.  BIN has the same
     size as X and holds 0 for elements that fall in no bin.  Note this differs
     from ‘discretize’, which returns NaN for such elements.

     The following NAME, VALUE pairs are supported.  When more than one of
     'NumBins', 'BinWidth', 'BinEdges' and 'BinMethod' is given, the last one
     specified takes effect.

     Name             Value
                      
     ----------------------------------------------------------------------------------
     'NumBins'        A positive integer scalar giving the number of bins,
                      equivalent to the NBINS syntax.
                      
     'BinEdges'       A vector of bin edges, equivalent to the EDGES syntax.
                      
     'BinWidth'       A positive finite scalar giving a uniform bin width.  The
                      edges are placed at multiples of the width covering the data.
                      
     'BinLimits'      A two-element vector ‘[LO, HI]’ restricting the binning to
                      that range.  Values outside it are not counted, and the
                      outermost edges are clamped to LO and HI.
                      
     'BinMethod'      One of 'auto' (default), 'scott', 'fd', 'integers', 'sturges'
                      or 'sqrt'.  'auto' uses the 'integers' rule when the data are
                      integer-valued and span at most 50, and 'scott' otherwise.
                      
     'Normalization'  One of 'count' (default), 'countdensity', 'cumcount',
                      'probability', 'percentage', 'pdf' or 'cdf'.  The divisor for
                      'probability', 'percentage', 'pdf' and 'cdf' is ‘numel (X)’,
                      not the number of elements actually counted, so values
                      excluded by being NaN or out of range still contribute to it.

     MATLAB accepts 'percentage' but omits it from the list of valid values in
     its own error message; it is documented here.

     See also: discretize.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
Histogram bin counts.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 438
 -- datatypes: D = hours (X)

     Fixed-time duration in hours.

     ‘D = hours (X)’ returns a duration array representing fixed-time duration
     hours equivalent to the values in X, which must be a numeric array.

     ‘hours’ is also available as a method for duration arrays, in which case it
     performs the opposite conversion.

     See also: duration, years, days, minutes, seconds, milliseconds,
     duration.hours.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
Fixed-time duration in hours.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
iscalendarduration


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 223
 -- datatypes: TF = iscalendarduration (X)

     True if input is a ‘calendarDuration’ array, false otherwise.

     ‘TF = iscalendarduration (X)’ always returns a logical scalar, irrespective
     of the size of X.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
True if input is a ‘calendarDuration’ array, false otherwise.

  



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 208
 -- datatypes: TF = iscategorical (X)

     True if input is a ‘categorical’ array, false otherwise.

     ‘TF = iscategorical (X)’ always returns a logical scalar, irrespective of
     the size of X.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
True if input is a ‘categorical’ array, false otherwise.

  



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 199
 -- datatypes: TF = isdatetime (X)

     True if input is a ‘datetime’ array, false otherwise.

     ‘TF = isdatetime (X)’ always returns a logical scalar, irrespective of the
     size of X.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
True if input is a ‘datetime’ array, false otherwise.

  



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 199
 -- datatypes: TF = isduration (X)

     True if input is a ‘duration’ array, false otherwise.

     ‘TF = isduration (X)’ always returns a logical scalar, irrespective of the
     size of X.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
True if input is a ‘duration’ array, false otherwise.

  



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 382
 -- datatypes: TF = isnat (T)

     Test for Not-A-Time elements in datetime array.

     ‘TF = isnat (T)’ returns a logical array TF of the same size as T
     containing true for each corresponding element of T that is Not-A-Time
     (NaT) and false otherwise.  NaT is the equivalent of NaN in numeric arrays.

     If T is not a datetime array, ‘isnat’ returns an error.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Test for Not-A-Time elements in datetime array.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 184
 -- datatypes: TF = istable (X)

     True if input is a ‘table’, false otherwise.

     ‘TF = istable (X)’ always returns a logical scalar, irrespective of the
     size of X.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
True if input is a ‘table’, false otherwise.

  



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 928
 -- datatypes: HEY = keyHash (X)
 -- datatypes: HEY = keyHash (X, BASE)

     Generate a hash code for an array.

     ‘H = keyHash (X)’ generates a uint64 scalar that represents the input X,
     which may be numeric, logical, or character array or cell array of
     character vectors.  ‘keyHash’ utilizes the 64-bit FNV-1a variant of the
     Fowler-Noll-Vo non-cryptographic hash function.

     ‘H = keyHash (X, BASE)’ also generates a 64-bit hash code using BASE as the
     offset basis for the FNV-1a hash algorithm.  BASE must be a uint64 integer
     type scalar.  Use this syntax to cascade ‘keyHash’ on multiple objects for
     which a single hash code is required.

     Note that unlike MATLAB, this implementation does not use any random seed.
     As a result, ‘keyHash’ will always generate the exact same hash key for any
     particular input across different workers and Octave sessions.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Generate a hash code for an array.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 262
 -- datatypes: TF = keyMatch (A, B)

     Return true if both inputs have the same hash code.

     ‘TF = keyMatch (A, B)’ returns a logical scalar, which is true, if both
     inputs, A and B, have the same FNV-1a 64-bit hash code, and false
     otherwise.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Return true if both inputs have the same hash code.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
milliseconds


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 478
 -- datatypes: D = milliseconds (X)

     Fixed-time duration in milliseconds.

     ‘D = milliseconds (X)’ returns a duration array representing fixed-time
     duration milliseconds equivalent to the values in X, which must be a
     numeric array.

     ‘milliseconds’ is also available as a method for duration arrays, in which
     case it performs the opposite conversion.

     See also: duration, years, days, hours, minutes, seconds,
     duration.milliseconds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Fixed-time duration in milliseconds.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 448
 -- datatypes: D = minutes (X)

     Fixed-time duration in minutes.

     ‘D = minutes (X)’ returns a duration array representing fixed-time duration
     minutes equivalent to the values in X, which must be a numeric array.

     ‘minutes’ is also available as a method for duration arrays, in which case
     it performs the opposite conversion.

     See also: duration, years, days, hours, seconds, milliseconds,
     duration.minutes.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Fixed-time duration in minutes.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 122
 -- datatypes: missing

     Array of missing values.

     A special class to represent missing data to other data types.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
Array of missing values.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 959
 -- datatypes: S = ods2struct (FILENAME)

     Read every sheet of an OpenDocument spreadsheet into a scalar structure.

     ‘S = ods2struct (FILENAME)’ reads each data sheet of the OpenDocument
     spreadsheet named by FILENAME into a ‘table’ and returns a scalar structure
     with one field per sheet, in sheet order.  Both the compressed .ods and the
     flat .fods formats are read.  Each sheet is reconstructed exactly as by
     ‘ods2table’; it is the inverse of ‘struct2ods’.

     A sheet name that is not a valid structure field name is canonicalised with
     ‘matlab.lang.makeValidName’ (and made unique if two sheet names collide).
     Whenever the field name differs from the sheet name, the original sheet
     name is stored on that field's table as the 'ActualSheetName' custom
     property, so a subsequent ‘struct2ods’ restores the exact sheet name.

     See also: struct2ods, ods2table, table2ods, readtable.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Read every sheet of an OpenDocument spreadsheet into a scalar structure.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1785
 -- datatypes: TBL = ods2table (FILENAME)
 -- datatypes: TBL = ods2table (FILENAME, 'Sheet', SHEET)

     Read an OpenDocument spreadsheet file into a table.

     ‘TBL = ods2table (FILENAME)’ reads the OpenDocument spreadsheet named by
     FILENAME, which may be a character vector, a cellstr, or a string scalar,
     and returns it as a ‘table’.  Both the compressed .ods and the flat .fods
     formats are read; the format is detected from the file contents, not its
     extension.

     ‘TBL = ods2table (..., 'Sheet', SHEET)’ reads a specific sheet, selected
     either by its name (a character vector or string scalar) or by a 1-based
     index over the data sheets.  Without this option the first data sheet is
     read.

     When the file carries the hidden __datatypes_meta__ sheet written by the
     ‘table2ods’ method, the variable types, names, descriptions, and units are
     restored from it, and ‘date’ and ‘time’ cells are reconstructed as
     ‘datetime’ and ‘duration’ arrays.  Integers are restored without loss of
     precision and missing cells become ‘NaN’, ‘NaT’, or missing strings as
     appropriate.

     When the metadata sheet is absent (a spreadsheet written by another
     application) the variable types are inferred from the cell value types and
     the variables are named Var1, Var2, and so on.

     The following round-trip limitations apply, mirroring ‘csv2table’:
     ‘calendarDuration’ and ‘categorical’ variables are returned as cell arrays
     of character vectors (their values are not reconstructed), missing ‘string’
     values are read back as empty strings, and datetime and duration display
     formats are not preserved, although the values themselves are exact.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Read an OpenDocument spreadsheet file into a table.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
parsePairedArguments


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1786
 -- datatypes: [OPTARG_1, ..., OPTARG_N] = parsePairedArguments (OPTARG_NAMES,
          DEFAULT_VALUES, ARG_LIST)
 -- datatypes: [OPTARG_1, ..., OPTARG_N, REM_ARGS] = parsePairedArguments
          (OPTARG_NAMES, DEFAULT_VALUES, ARG_LIST)

     Parse optional paired arguments from variable argument list.

     ‘parsePairedArguments’ parses the optional paired arguments specified by
     OPTARG_NAMES from the variable input argument list, ARG_LIST.  Any
     OPTARG_NAMES that are not found in ARG_LIST are returned with their default
     value specified by DEFAULT_VALUES, which must be a cell array with the same
     number of elements as OPTARG_NAMES.

     OPTARG_NAMES must be a cell array of character vectors or a string array
     with the same number of elements as the number of output arguments
     specified as ‘[OPTARG_1, ..., OPTARG_N]’, while an extra output argument,
     REM_ARGS, may be specified for the remaining input arguments in ARG_LIST
     that were not specified by OPTARG_NAMES.

     Each property name specified by OPTARG_NAMES is case insensitive.

     A property specified more than once in ARG_LIST takes the value of its last
     occurrence, as in MATLAB. Every occurrence is consumed, so none of them is
     returned in REM_ARGS.

     The following example illustrates how to use ‘parsePairedArguments’ inside
     a function to parse optional paired arguments for three properties, namely
     'A', 'B', and 'C'.

          ## Declare optional property Names and their default Values
          optNames = {'A', 'B', 'C'};
          dfValues = {1, 2, 3};

          ## Parse optional Name-Value paired arguments
          [var_A, var_B, var_C, args] = ...
                       parsePairedArguments (optNames, dfValues, args);


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Parse optional paired arguments from variable argument list.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2204
 -- datatypes: TBL = readtable (FILENAME)
 -- datatypes: TBL = readtable (FILENAME, NAME, VALUE)

     Read a file into a table, detecting variable types automatically.

     ‘TBL = readtable (FILENAME)’ reads the file named by FILENAME (a character
     vector or string scalar) and returns it as a ‘table’.  The file type is
     inferred from the extension: .txt, .csv, and .dat are read as delimited
     text; .ods and .fods are read as OpenDocument spreadsheets.  Use the
     'FileType' option to override the inferred type.

     By default the first row supplies the variable names and each column's data
     type is detected automatically (numeric, ‘datetime’, ‘duration’, or text).
     The following NAME-VALUE options are supported:

     NAME                   VALUE
     ----------------------------------------------------------------------------------
     'FileType'             'text' or 'spreadsheet'.
     'ReadVariableNames'    Logical; read the first row as variable names (default
                            true).
     'ReadRowNames'         Logical; read the first column as row names (default
                            false).
     'Delimiter'            Field delimiter for text files: a single character or
                            one of 'comma', 'space', 'tab', 'semi', 'bar' (default
                            ',').
     'NumHeaderLines'       Number of lines to skip before the header (default 0).
     'TextType'             'char' or 'string' for text columns (default 'char').
     'VariableNamingRule'   'modify' or 'preserve' (default 'modify').
     'Sheet'                Spreadsheet only: the sheet to read, selected by name or
                            by a 1-based index over the data sheets (default: the
                            first sheet).
     'Range'                Spreadsheet only: an A1-style range such as 'C5' or
                            'C5:D8' limiting the region read.

     Office Open XML spreadsheets (.xlsx, .xlsm) are read via the same interface
     as ODS. The legacy binary formats .xls and .xlsb are not supported; use
     .xlsx, .ods, or a text format.

     See also: writetable, csv2table, ods2table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Read a file into a table, detecting variable types automatically.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 448
 -- datatypes: D = seconds (X)

     Fixed-time duration in seconds.

     ‘D = seconds (X)’ returns a duration array representing fixed-time duration
     seconds equivalent to the values in X, which must be a numeric array.

     ‘seconds’ is also available as a method for duration arrays, in which case
     it performs the opposite conversion.

     See also: duration, years, days, hours, minutes, milliseconds,
     duration.seconds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Fixed-time duration in seconds.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1180
 -- datatypes: Y = splitapply (FUNC, X, G)
 -- datatypes: Y = splitapply (FUNC, X1, ..., XN, G)
 -- datatypes: [Y1, ..., YM] = splitapply (...)

     Split data into groups and apply a function to each group.

     ‘Y = splitapply (FUNC, X, G)’ splits the data variable X into groups
     according to the group numbers G (typically produced by ‘findgroups’),
     applies the function handle FUNC to each group, and concatenates the
     per-group results into the output Y.  G must be a vector of positive
     integers with one element per element of X; if it identifies N groups,
     every integer between 1 and N must occur at least once.  Elements for which
     G is ‘NaN’ are omitted.

     ‘Y = splitapply (FUNC, X1, ..., XN, G)’ splits each of the data variables
     X1, ..., XN and passes the corresponding group of each as a separate input
     argument to FUNC.

     ‘[Y1, ..., YM] = splitapply (...)’ returns the multiple outputs of FUNC,
     each concatenated across groups.

     To split the variables of a ‘table’, call ‘splitapply (FUNC, T, G)’, which
     dispatches to the ‘table’ method.

     See also: findgroups, table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Split data into groups and apply a function to each group.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 831
 -- datatypes: string

     Array representing sequences of characters.

     A string array is an array, where each element stores a sequence of
     characters of arbitrary length.

     A string array can also have missing elements, which differ from a sequence
     of characters of zero length (the equivalent of an empty character vector).

     To enable existing functions to handle string arrays as if they were cell
     arrays of character vectors or character arrays, use the
     ‘convertCharsToStrings’ function inside your code.  To enable functions
     working with string arrays to accept cell arrays of character vectors or
     character vectors as if they were string arrays or string scalars, use the
     ‘convertStringsToChars’ function.

     See also: convertCharsToStrings, convertStringsToChars.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Array representing sequences of characters.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1144
 -- datatypes: struct2ods (FILENAME, S)

     Write a scalar structure of tables to a multi-sheet OpenDocument
     spreadsheet.

     ‘struct2ods (FILENAME, S)’ writes each field of the scalar structure S to
     its own sheet in the OpenDocument spreadsheet named by FILENAME.  Every
     field of S must hold a ‘table’; the field name becomes the sheet name.
     Both the compressed .ods and the flat .fods formats are supported, selected
     by the file extension.

     Full type fidelity is preserved through a hidden, sectioned
     __datatypes_meta__ sheet, exactly as for the single-table ‘table2ods’
     method; the workbook round-trips through ‘ods2struct’.

     A field whose table carries an 'ActualSheetName' custom property (see
     ‘addprop’) uses that value as the sheet name instead of the field name,
     which lets a sheet name that is not a valid identifier (for example 'Sales
     2024') round-trip.  Sheet names must be non-empty and must not contain any
     of the characters [ ] * ?  : / \, and the resolved names must be unique.

     See also: ods2struct, table2ods, ods2table, writetable.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
Write a scalar structure of tables to a multi-sheet OpenDocument spreadsheet.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
struct2table


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1590
 -- datatypes: TBL = struct2table (S)
 -- datatypes: TBL = struct2table (S, NAME, VALUE)

     Convert a structure array to a table.

     ‘TBL = struct2table (S)’ converts a structure array S to the table TBL,
     where each field of the input structure becomes a variable in the output
     table.  For a scalar structure with N fields, all of which have M rows, or
     an M*1 or 1*M structure array with N fields, the output is an M*N table.

     ‘TBL = struct2table (S, NAME, VALUE)’ specifies optional parameters for
     creating the table TBL with the following Name-Value paired arguments.

     NAME               VALUE
                        
     --------------------------------------------------------------------------------
     'AsArray'          A logical scalar specifying whether to treat a scalar
                        input as a structure array, which allows the fields
                        containing data of different sizes.
                        
     'RowNames'         A cell array of character vectors or a string array
                        defining the row names of TBL.  The names must be unique
                        but not necessarily valid variable names.
                        
     'DimensionNames'   A cell array of character vectors or a string array
                        defining the dimension names of TBL.  The names must be
                        unique and not in conflict with variable names.  By
                        default, dimension names are 'Row', 'Variables'.

     See also: array2table, cell2table, table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Convert a structure array to a table.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 983
 -- datatypes: struct2xlsx (FILENAME, S)

     Write a scalar structure of tables to a multi-sheet Excel workbook.

     ‘struct2xlsx (FILENAME, S)’ writes each field of the scalar structure S to
     its own sheet in the Office Open XML workbook named by FILENAME (.xlsx or
     .xlsm).  Every field must hold a ‘table’; the field name becomes the sheet
     name.

     This is the Excel counterpart of ‘struct2ods’.  Like ‘writetable’, it
     writes the MATLAB-interoperable format (a variable-name header row followed
     by the data, with no hidden type metadata); read it back with
     ‘xlsx2struct’.  A field whose table carries an 'ActualSheetName' custom
     property uses that value as the sheet name instead of the field name.
     Sheet names must be non-empty, at most 31 characters, and must not contain
     any of the characters [ ] * ?  : / \; the resolved names must be unique.

     See also: xlsx2struct, struct2ods, writetable, readtable.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Write a scalar structure of tables to a multi-sheet Excel workbook.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1484
 -- datatypes: table

     Array of tabular data containing multiple columnar variables.

     A table is a 2-dimensional data structure that collects heterogeneous data
     and metadata into a single container.  Tables are suitable for storing
     columnar data much like spreadsheets but they can also be used for storing
     more complex data including multicolumnar variables and nested tables.

     Tables can be subscripted using parentheses like ordinary numeric arrays,
     but in addition to indexing with numeric and logical vectors, you can also
     use the table's variable or row names much like indexing a structure field
     as well as using a vartype class object to make a selection of variable
     types.  While these methods will return a subset of the original table, you
     can also use curly brackets much like cell arrays to retrieve the contents
     of the table.  In this case, the original data types of the selected
     variables are returned.

     Besides the ‘table’ constructor, you can also use ‘array2table’,
     ‘cell2table’, and ‘struct2table’ to create tables from the respective data
     types.

     Besides all numeric data types, other supported data types that can be
     stored in a table array are logical, categorical, cell, (including
     cellstr), calendarDuration, duration, datetime, string, and struct arrays,
     as well as table itself.

     See also: vartype, array2table, cell2table, struct2table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Array of tabular data containing multiple columnar variables.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 195
 -- datatypes: vartype

     Subscript into a table by variable type.

     A utility class that facilitates subscripting table variables according to
     their data type.

     See also: table.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Subscript into a table by variable type.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 932
 -- datatypes: S = xlsx2struct (FILENAME)

     Read every sheet of an Excel workbook into a scalar structure.

     ‘S = xlsx2struct (FILENAME)’ reads each sheet of the Office Open XML
     workbook named by FILENAME (.xlsx or .xlsm) into a ‘table’ and returns a
     scalar structure with one field per sheet, in sheet order.  Each sheet is
     read as by ‘readtable’ (variable names from the first row, types detected
     automatically); it is the inverse of ‘struct2xlsx’.

     A sheet name that is not a valid structure field name is canonicalised with
     ‘matlab.lang.makeValidName’ (and made unique if two names collide); when
     the field name differs from the sheet name the original is stored on that
     field's table as the 'ActualSheetName' custom property, so a subsequent
     ‘struct2xlsx’ restores the exact sheet name.

     See also: struct2xlsx, readtable, writetable, ods2struct.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Read every sheet of an Excel workbook into a scalar structure.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 491
 -- datatypes: D = years (X)

     Fixed-time duration in years.

     ‘D = years (X)’ returns a duration array representing fixed-time duration
     years equivalent to the values in X, which must be a numeric array.  A
     fixed-length year is equal to 365.2425 days.

     ‘years’ is also available as a method for duration arrays, in which case it
     performs the opposite conversion.

     See also: duration, days, hours, minutes, seconds, milliseconds,
     duration.years.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
Fixed-time duration in years.





