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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 805
 -- Function: OUT = NaC ()
 -- Function: OUT = NaC (SZ)

     “Not-a-Categorical".  Creates missing-valued categorical arrays.

     Returns a new ‘categorical’ array of all missing values of the given size.
     If no input SZ is given, the result is a scalar missing categorical.

     ‘NaC’ is the ‘categorical’ equivalent of ‘NaN’ or ‘NaT’.  It represents a
     missing, invalid, or null value.  ‘NaC’ values never compare equal to any
     value, including other ‘NaC’s.

     ‘NaC’ is a convenience function which is strictly a wrapper around
     ‘categorical.undefined’ and returns the same results, but may be more
     convenient to type and/or more readable, especially in array expressions
     with several values.

     See also: categorical.undefined.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
“Not-a-Categorical".  



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
NaS


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 767
 -- Function: OUT = NaS ()
 -- Function: OUT = NaS (SZ)

     “Not-a-String".  Creates missing-valued string arrays.

     Returns a new ‘string’ array of all missing values of the given size.  If
     no input SZ is given, the result is a scalar missing string.

     ‘NaS’ is the ‘string’ equivalent of ‘NaN’ or ‘NaT’.  It represents a
     missing, invalid, or null value.  ‘NaS’ values never compare equal to any
     value, including other ‘NaS’s.

     ‘NaS’ is a convenience function which is strictly a wrapper around
     ‘string.missing’ and returns the same results, but may be more convenient
     to type and/or more readable, especially in array expressions with several
     values.

     See also: string.missing.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
“Not-a-String".  



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
NaT


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 700
 -- Function: OUT = NaT ()
 -- Function: OUT = NaT (SZ)

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

     Constructs a new ‘datetime’ array of all ‘NaT’ values of the given size.
     If no input SZ is given, the result is a scalar ‘NaT’.

     ‘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 ‘NaT’s.  Doing arithmetic with a ‘NaT’ and
     any other value results in a ‘NaT’.

     ‘NaT’ currently cannot create NaT arrays of type ‘localdate’.  To do that,
     use localdate.NaT instead.


# 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: 760
 -- Function: OUT = array2table (C)
 -- Function: OUT = array2table (..., 'VariableNames', VARIABLENAMES)
 -- Function: OUT = array2table (..., 'RowNames', ROWNAMES)

     Convert an array to a table.

     Converts a 2-D array to a table, with columns in the array becoming
     variables in the output table.  This is typically used on numeric arrays,
     but it can be applied to any type of array.

     You may not want to use this on cell arrays, though, because you will end
     up with a table that has all its variables of type cell.  If you use
     ‘cell2table’ instead, columns of the cell array which can be condensed into
     primitive arrays will be.  With ‘array2table’, they won't be.

     See also: cell2table, table, struct2table


# 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: 424
 -- Function File: OUT = caldays (X)
     Create a ‘calendarDuration’ that is a given number of calendar days long.

     Input X is a numeric array specifying the number of calendar days.

     This is a shorthand alternative to calling the ‘calendarDuration’
     constructor with ‘calendarDuration(0, 0, x)’.

     Returns a new ‘calendarDuration’ object of the same size as X.

     See calendarDuration.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 81
Create a ‘calendarDuration’ that is a given number of calendar days long.

  



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 430
 -- Function File: OUT = calmonths (X)
     Create a ‘calendarDuration’ that is a given number of calendar months long.

     Input X is a numeric array specifying the number of calendar months.

     This is a shorthand alternative to calling the ‘calendarDuration’
     constructor with ‘calendarDuration(0, x, 0)’.

     Returns a new ‘calendarDuration’ object of the same size as X.

     See calendarDuration.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 83
Create a ‘calendarDuration’ that is a given number of calendar months long.

  



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 202
 -- Function: OUT = calyears (X)

     Construct a ‘calendarDuration’ a given number of years long.

     This is a shorthand for calling ‘calendarDuration(X, 0, 0)’.

     See calendarDuration.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Construct a ‘calendarDuration’ a given number of years long.

  



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 555
 -- Function: OUT = cell2table (C)
 -- Function: OUT = cell2table (..., 'VariableNames', VARIABLENAMES)
 -- Function: OUT = cell2table (..., 'RowNames', ROWNAMES)

     Convert a cell array to a table.

     Converts a 2-dimensional cell matrix into a table.  Each column in the
     input C becomes a variable in OUT.  For columns that contain all scalar
     values of ‘cat’-compatible types, they are “popped out” of their cells and
     condensed into a homogeneous array of the contained type.

     See also: array2table, table, struct2table


# 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: 9
colvecfun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 574
 -- Function: OUT = colvecfun (FCN, X)

     Apply a function to column vectors in array.

     Applies the given function FCN to each column vector in the array X, by
     iterating over the indexes along all dimensions except dimension 1.
     Collects the function return values in an output array.

     FCN must be a function which takes a column vector and returns a column
     vector of the same size.  It does not have to return the same type as X.

     Returns the result of applying fcn to each column in x, all concatenated
     together in the same shape as x.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Apply a function to column vectors in array.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 685
 -- Function: OUT = colvecfun (STR, PATTERN)
 -- Function: OUT = colvecfun (..., 'IgnoreCase', IGNORECASE)

     Test if strings contain a pattern.

     Tests whether the given strings contain the given pattern(s).

     STR (char, cellstr, or string) is a list of strings to compare against
     pattern.

     PATTERN (char, cellstr, or string) is a list of patterns to match.  These
     are literal plain string patterns, not regex patterns.  If more than one
     pattern is supplied, the return value is true if the string matched any of
     them.

     Returns a logical array of the same size as the string array represented by
     STR.

     See also: startsWith, endsWith.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Test if strings contain a pattern.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 335
 -- Function: OUT = days (X)

     Duration in days.

     If X is numeric, then OUT is a ‘duration’ array in units of fixed-length
     24-hour days, with the same size as X.

     If X is a ‘duration’, then returns a ‘double’ array the same size as X
     indicating the number of fixed-length days that each duration is.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
Duration in days.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 742
 -- Function: [Y, E] = discretize (X, N)
 -- Function: [Y, E] = discretize (X, EDGES)
 -- Function: [Y, E] = discretize (X, DUR)
 -- Function: [Y, E] = discretize (..., 'categorical')
 -- Function: [Y, E] = discretize (..., 'IncludedEdge', INCLUDEDEDGE)

     Group data into discrete bins or categories.

     N is the number of bins to group the values into.

     EDGES is an array of edge values defining the bins.

     DUR is a ‘duration’ value indicating the length of time of each bin.

     If ‘'categorical'’ is specified, the resulting values are a ‘categorical’
     array instead of a numeric array of bin indexes.

     Returns: Y - the bin index or category of each value from X E - the list of
     bin edge values


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 646
 -- Function: OUT = dispstrs (X)

     Display strings for array.

     Gets the display strings for each element of X.  The display strings should
     be short, one-line, human-presentable strings describing the value of that
     element.

     The default implementation of ‘dispstrs’ can accept input of any type, and
     has decent implementations for Octave’s standard built-in types, but will
     have opaque displays for most user-defined objects.

     This is a polymorphic method that user-defined classes may override with
     their own custom display that is more informative.

     Returns a cell array the same size as X.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Display strings for array.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
eqn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 950
 -- Function: OUT = eqn (A, B)

     Determine element-wise equality, treating NaNs as equal

     out = eqn (A, B)

     ‘eqn’ is just like ‘eq’ (the function that implements the ‘==’ operator),
     except that it considers NaN and NaN-like values to be equal.  This is the
     element-wise equivalent of ‘isequaln’.

     ‘eqn’ uses ‘isnanny’ to test for NaN and NaN-like values, which means that
     NaNs and NaTs are considered to be NaN-like, and string arrays’ “missing”
     and categorical objects’ “undefined” values are considered equal, because
     they are NaN-ish.

     Developer's note: the name “‘eqn’” is a little unfortunate, because “eqn”
     could also be an abbreviation for “equation”.  But this name follows the
     ‘isequaln’ pattern of appending an “n” to the corresponding
     non-NaN-equivocating function.

     See also: ‘eq’, ‘isequaln’, isnanny


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Determine element-wise equality, treating NaNs as equal



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 650
 -- Function: OUT = head (A)
 -- Function: OUT = head (A, K)

     Get first K rows of an array.

     Returns the array A, subsetted to its first K rows.  This means subsetting
     it to the first ‘(min (k, size (A, 1)))’ elements along dimension 1, and
     leaving all other dimensions unrestricted.

     A is the array to subset.

     K is the number of rows to get.  K defaults to 8 if it is omitted or empty.

     If there are less than K rows in A, returns all rows.

     Returns an array of the same type as A, unless ()-indexing A produces an
     array of a different type, in which case it returns that type.

     See also: tail.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
Get first K rows of an array.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 342
 -- Function File: OUT = hours (X)
     Create a ‘duration’ X hours long, or get the hours in a ‘duration’ X.

     If input is numeric, returns a ‘duration’ array that is that many hours in
     time.

     If input is a ‘duration’, converts the ‘duration’ to a number of hours.

     Returns an array the same size as X.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 85
Create a ‘duration’ X hours long, or get the hours in a ‘duration’ X.

   If 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 341
 -- Function: OUT = iscalendarduration (X)

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

     Respects ‘iscalendarduration’ override methods on user-defined classes,
     even if they do not inherit from ‘calendarDuration’ or were known to
     Tablicious at authoring time.

     Returns a scalar logical.


# 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: 321
 -- Function: OUT = iscategorical (X)

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

     Respects ‘iscategorical’ override methods on user-defined classes, even if
     they do not inherit from ‘categorical’ or were known to Tablicious at
     authoring time.

     Returns a scalar logical.


# 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: 309
 -- Function: OUT = isdatetime (X)

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

     Respects ‘isdatetime’ override methods on user-defined classes, even if
     they do not inherit from ‘datetime’ or were known to Tablicious at
     authoring time.

     Returns a scalar logical.


# 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: 309
 -- Function: OUT = isduration (X)

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

     Respects ‘isduration’ override methods on user-defined classes, even if
     they do not inherit from ‘duration’ or were known to Tablicious at
     authoring time.

     Returns a scalar logical.


# 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: 7
isnanny


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1118
 -- Function: OUT = isnanny (X)

     Test if elements are NaN or NaN-like.

     Tests if input elements are NaN, NaT, or otherwise NaN-like.  This is true
     if ‘isnan()’ or ‘isnat()’ returns true, and is false for types that do not
     support ‘isnan()’ or ‘isnat()’.

     This function only exists because:

       a. Matlab decided to call their NaN values for datetime “NaT” instead,
          and test for them with a different “isnat()” function, and
       b. isnan() errors out for some types that do not support isnan(), like
          cells.
       c. Octave does not define an ‘ismissing’ function, but the Octave Forge
          statistics package does, and adding an ‘ismissing’ function to
          Tablicious would conflict with that in hard-to-resolve ways.

     ‘isnanny()’ smooths over those differences so you can call it
     polymorphically on any input type.  Hopefully.

     Under normal operation, ‘isnanny()’ should not throw an error for any type
     or value of input.

     See also: ismissing, ‘isnan’, ‘isnat’, eqn, ‘isequaln’


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Test if elements are NaN or NaN-like.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 552
 -- Function: OUT = istable (X)

     True if input is a ‘table’ array or other table-like type, false otherwise.

     Respects ‘istable’ override methods on user-defined classes, even if they
     do not inherit from ‘table’ or were known to Tablicious at authoring time.

     User-defined classes should only override ‘istable’ to return true if they
     conform to the ‘table’ public interface.  That interface is not
     well-defined or documented yet, so maybe you don't want to do that yet.

     Returns a scalar logical.


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

  



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 359
 -- Function: OUT = istabular (X)

     True if input is eitehr a ‘table’ or ‘timetable’ array, or an object like
     them.

     Respects ‘istable’ and ‘istimetable’ override methods on user-defined
     classes, even if they do not inherit from ‘table’ or were known to
     Tablicious at authoring time.

     Returns a scalar logical.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 88
True if input is eitehr a ‘table’ or ‘timetable’ array, or an object like the...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 582
 -- Function: OUT = istimetable (X)

     True if input is a ‘timetable’ array or other timetable-like type, false
     otherwise.

     Respects ‘istimetable’ override methods on user-defined classes, even if
     they do not inherit from ‘table’ or were known to Tablicious at authoring
     time.

     User-defined classes should only override ‘istimetable’ to return true if
     they conform to the ‘table’ public interface.  That interface is not
     well-defined or documented yet, so maybe you don't want to do that yet.

     Returns a scalar logical.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 84
True if input is a ‘timetable’ array or other timetable-like type, false
othe...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 908
 -- Class: localdate

     Represents a complete day using the Gregorian calendar.

     This class is useful for indexing daily-granularity data or representing
     time periods that cover an entire day in local time somewhere.  The major
     purpose of this class is "type safety", to prevent time-of-day values from
     sneaking in to data sets that should be daily only.  As a secondary
     benefit, this uses less memory than datetimes.

 -- Instance Variable of localdate: double dnums

     The underlying datenum values that represent the days.  The datenums are at
     the midnight that is at the start of the day it represents.

     These are doubles, but they are restricted to be integer-valued, so they
     represent complete days, with no time-of-day component.

 -- Instance Variable of localdate: char Format

     The format to display this ‘localdate’ in.  Currently unsupported.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Represents a complete day using the Gregorian calendar.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 387
 -- Function File: OUT = milliseconds (X)
     Create a ‘duration’ X milliseconds long, or get the milliseconds in a
     ‘duration’ X.

     If input is numeric, returns a ‘duration’ array that is that many
     milliseconds in time.

     If input is a ‘duration’, converts the ‘duration’ to a number of
     milliseconds.

     Returns an array the same size as X.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 86
Create a ‘duration’ X milliseconds long, or get the milliseconds in a ‘durati...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 117
 -- Function File: OUT = hours (X)
     Create a ‘duration’ X hours long, or get the hours in a ‘duration’ X.


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




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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 255
 TODO: Because there is only one missing value, this could probably be
 optimized to just store a size variable, and not store the .data property.
 I'm just using that now because it was easy to implement, due to my existing
 planar-gen boilerplate code.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 TODO: Because there is only one missing value, this could probably be
 optim...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2
pp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 479
 -- Function: pp (X)
 -- Function: pp (A, B, C, ...)
 -- Function: pp ('A', 'B', 'C', ...)
 -- Function: pp A B C ...

     Alias for prettyprint, for interactive use.

     This is an alias for prettyprint(), with additional name-conversion magic.

     If you pass in a char, instead of pretty-printing that directly, it will
     grab and pretty-print the variable of that name from the caller’s
     workspace.  This is so you can conveniently run it from the command line.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Alias for prettyprint, for interactive use.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3146
PROXYKEYSFORMATRIXES Compute row proxy keys for matrices

 pkA = proxykeysForMatrixes (A)
 [pkA, pkB] = proxykeysForMatrixes (A, B)

 Computes row-identity "proxy key" matrix pairs for input matrices. A proxy
 key matrix pair is a pair of double matrices whose respective rows have the
 same identity and ordering relationships (both within the same matrix and
 across the two matrices) as the corresponding rows in the input matrices.
 In the case of one input, proxy keys are computed for that matrix on its own,
 without reference to any other input.

 Proxy keys are used by table for efficient computation of record identity/equality
 and ordering for tables with heterogeneous variable types.

 For an m1-by-n A and m2-by-n B, pkA and pkB will be m1-by-k and m2-by-k,
 respectively. k is not necessarily the same as n; it may be smaller or larger.

 The identity and ordering relationships between rows will be true even in
 the case of NaN and NaN-like inputs, including the case where some but not
 all of the columns in the

 In particular, this means that the following relationships hold:

   [tf, s_idx] = ismember(pkA, pkB, 'rows')
   [tf, s_idx] = ismember(A, B, 'rows')           % same tf, s_idx results

   all(pkA(i,:) == pkB(j,:), 2) == all(A(i,:), B(j,:), 2)   % For any i, j

   any(isnan(pkA), 2) == any(isnanny(A), 2)
   % where "isnanny()" uses whichever of isnan() or isnat() is defined for A

   [~, s_idx] = sortrows(A)
   [~, s_idx] = sortrows(pkA)  % same s_idx result

 (The more-specific identity of Octave isna() inputs versus isnan()-but-not-isna()
 inputs is *not* preserved. This is a limitation of the current proxykeysForMatrixes
 implementation, not necessarily a limitation of the semantics of the isna()
 interface, so this shortcoming may be addressed in the future.)

 The generic proxykeysForMatrixes function can compute proxy keys for any type
 that supports the `unique()` function (as long as that unique()
 implementation does not itself depend on proxykeysForMatrixes).

 Note that the proxy key identity and ordering relationships:
  a) Are for entire *rows* of matrices, not individual *elements* within the
     matrix. In particular, a given value x in one column of A may be represented
     by one proxy key element value in one column of pkA, and another proxy key
     element value in another column of pkA.
  b) Only hold within the scope of the specific values in A and B, so they are
     only good for comparisons between those two specific matrices. The proxy
     key values for a given row in A may change if either other rows in A have
     different values, or if any rows in B have different values. That is, for:
         [pkA1, pkB] = proxykeysForMatrixes (A, B)
         [pkA2, pkC] = proxykeysForMatrixes (A, C)
     pkA1 and pkA2 may not be the same values.

 User-defined classes may override proxykeysForMatrixes to provide optimized
 implementations, or so that their unique() implementations may themselves use
 proxykeysForMatrixes. This may be especially useful for classes which are
 represented internally by single numeric matrices.

 This is an Octave extension.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
PROXYKEYSFORMATRIXES Compute row proxy keys for matrices



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 766
 -- Function: [OUT1, OUT2, ..., OUTN] = scalarexpand (X1, X2, ..., XN)

     Expand scalar inputs to match size of non-scalar inputs.

     Expands each scalar input argument to match the size of the non-scalar
     input arguments, and returns the expanded values in the corresponding
     output arguments.  ‘repmat’ is used to do the expansion.

     Works on any input types that support ‘size’, ‘isscalar’, and ‘repmat’.

     It is an error if any of the non-scalar inputs are not the same size as all
     of the other non-scalar inputs.

     Returns as many output arguments as there were input arguments.

     Examples:

          x1 = rand(3);
          x2 = 42;
          x3 = magic(3);
          [x1, x2, x3] = scalarexpand (x1, x2, x3)


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Expand scalar inputs to match size of non-scalar inputs.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 352
 -- Function File: OUT = seconds (X)
     Create a ‘duration’ X seconds long, or get the seconds in a ‘duration’ X.

     If input is numeric, returns a ‘duration’ array that is that many seconds
     in time.

     If input is a ‘duration’, converts the ‘duration’ to a number of seconds.

     Returns an array the same size as X.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 88
Create a ‘duration’ X seconds long, or get the seconds in a ‘duration’ X.

  ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 466
 -- Function: OUT = size2str (SZ)

     Format an array size for display.

     Formats the given array size SZ as a string for human-readable display.  It
     will be in the format “d1-by-d2-...-by-dN”, for the N dimensions
     represented by SZ.

     SZ is an array of dimension sizes, in the format returned by the ‘size’
     function.

     Returns a charvec.

     Examples:
          str = size2str (size (magic (4)))
              ⇒ str = 4-by-4


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Format an array size for display.



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


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

     Split data into groups and apply function.

     FUNC is a function handle to call on each group of inputs in turn.

     X, X1, ..., XN are the input variables that are split into groups for the
     function calls.  If X is a ‘table’, then its contained variables are
     “popped out” and considered to be the X1 ... XN input variables.

     G is the grouping variable vector.  It contains a list of integers that
     identify which group each element of the X input variables belongs to.
     NaNs in G mean that element is ignored.

     Vertically concatenates the function outputs for each of the groups and
     returns them in as many variables as you capture.

     Returns the concatenated outputs of applying FUNC to each group.

     See also: table.groupby, table.splitapply


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Split data into groups and apply function.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 318
 -- Function: OUT = struct2table (S)
 -- Function: OUT = struct2table (..., 'AsArray', ASARRAY)

     Convert struct to a table.

     Converts the input struct S to a ‘table’.

     S may be a scalar struct or a nonscalar struct array.

     The ASARRAY option is not implemented yet.

     Returns a ‘table’.


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 647
 -- Function: OUT = tail (A)
 -- Function: OUT = tail (A, K)

     Get last K rows of an array.

     Returns the array A, subsetted to its last K rows.  This means subsetting
     it to the last ‘(min (k, size (A, 1)))’ elements along dimension 1, and
     leaving all other dimensions unrestricted.

     A is the array to subset.

     K is the number of rows to get.  K defaults to 8 if it is omitted or empty.

     If there are less than K rows in A, returns all rows.

     Returns an array of the same type as A, unless ()-indexing A produces an
     array of a different type, in which case it returns that type.

     See also: head.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
Get last K rows of an array.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 895
 -- Function: OUT = timezones ()
 -- Function: OUT = timezones (AREA)

     List all the time zones defined on this system.

     This lists all the time zones that are defined in the IANA time zone
     database used by this Octave.  (On Linux and macOS, that will generally be
     the system time zone database from ‘/usr/share/zoneinfo’.  On Windows, it
     will be the database redistributed with the Tablicious package.

     If the return is captured, the output is returned as a table if your Octave
     has table support, or a struct if it does not.  It will have
     fields/variables containing column vectors:

     ‘Name’
          The IANA zone name, as cellstr.
     ‘Area’
          The geographical area the zone is in, as cellstr.

     Compatibility note: Matlab also includes UTCOffset and DSTOffset fields in
     the output; these are currently unimplemented.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
List all the time zones defined on this system.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 837
 -- Function: OUT = todatetime (X)

     Convert input to a Tablicious datetime array, with convenient interface.

     This is an alternative to the regular datetime constructor, with a
     signature and conversion logic that Tablicious's author likes better.

     This mainly exists because datetime's constructor signature does not accept
     datenums, and instead treats one-arg numeric inputs as datevecs.  (For
     compatibility with Matlab's interface.)  I think that's less convenient:
     datenums seem to be more common than datevecs in M-code, and it returns an
     object array that's not the same size as the input.

     Returns a datetime array whose size depends on the size and type of the
     input array, but will generally be the same size as the array of strings or
     numerics the input array "represents".


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Convert input to a Tablicious datetime array, with convenient interface.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 576
 -- Function: OUT = vartype (TYPE)

     Filter by variable type for use in suscripting.

     Creates an object that can be used for subscripting into the variables
     dimension of a table and filtering on variable type.

     TYPE is the name of a type as charvec.  This may be anything that the ‘isa’
     function accepts, or ‘'cellstr'’ to select cellstrs, as determined by
     ‘iscellstr’.

     Returns an object of an opaque type.  Don’t worry about what type it is;
     just pass it into the second argument of a subscript into a ‘table’ object.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Filter by variable type for use in suscripting.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 596
 -- Function: OUT = vecfun (FCN, X, DIM)

     Apply function to vectors in array along arbitrary dimension.

     This function is not implemented yet.

     Applies a given function to the vector slices of an N-dimensional array,
     where those slices are along a given dimension.

     FCN is a function handle to apply.

     X is an array of arbitrary type which is to be sliced and passed in to FCN.

     DIM is the dimension along which the vector slices lay.

     Returns the collected output of the FCN calls, which will be the same size
     as X, but not necessarily the same type.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Apply function to vectors in array along arbitrary dimension.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 559
 -- Function File: OUT = years (X)
     Create a ‘duration’ X years long, or get the years in a ‘duration’ X.

     If input is numeric, returns a ‘duration’ array in units of fixed-length
     years of 365.2425 days each.

     If input is a ‘duration’, converts the ‘duration’ to a number of
     fixed-length years as double.

     Note: ‘years’ creates fixed-length years, which may not be what you want.
     To create a duration of calendar years (which account for actual leap
     days), use ‘calyears’.

     See calyears.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 85
Create a ‘duration’ X years long, or get the years in a ‘duration’ X.

   If 





