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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1239
 -- 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 n 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: 17
“Not-a-Time”.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1811
 -- 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 wat 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: 981
 -- 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: 1062
 -- 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
     absense 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 similarily 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: 1690
 -- 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 collumn 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 = array2table (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: 772
 -- 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: 11378
 -- 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: 780
 -- 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: 438
 -- 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: 936
 -- 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: 443
 -- 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: 65
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: 60
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: 57
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: 57
True if input is a ‘duration’ array, false otherwise.



# 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: 48
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: 938
 -- 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 FMV-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 no 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: 453
 -- 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: 7
seconds


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 453
 -- 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: 836
 -- 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: 1602
 -- datatypes: TBL = struct2table (S)
 -- datatypes: TBL = struct2table (S, NAME, VALUE)

     Convert a cell 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 = array2table (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: 32
Convert a cell array to a table.



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


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





