# doc-cache created by Octave 11.3.0
# name: cache
# type: cell
# rows: 3
# columns: 35
# 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 NxN 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: 1839
 -- 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: 1719
 -- 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: 11355
 -- 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".

     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: 775
 -- 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.

     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: 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: 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: 20
parsePairedArguments


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1570
 -- 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.

     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: 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: 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: 12
struct2table


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1635
 -- 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 Mx1 or 1xM structure array with N fields, the output is an MxN 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: 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 used curly brackets much like cell arrays to retrieve the contents
     of the table.  In this case, the original data type 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: 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.





