# doc-cache created by Octave 10.2.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: 811
 -- 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: 22
“Not-a-Categorical".



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 772
 -- 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: 17
“Not-a-String".



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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 764
 -- 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: 429
 -- 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: 77
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: 440
 -- 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: 79
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: 64
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: 560
 -- 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: 585
 -- 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: 684
 -- 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: 340
 -- 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: 747
 -- 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: 660
 -- 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: 352
 -- 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: 77
Create a ‘duration’ X hours long, or get the hours in a ‘duration’ X.



# 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: 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: 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: 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: 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: 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: 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: 57
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: 896
 -- 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.

     ‘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: 36
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: 567
 -- 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: 79
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: 80
True if input is eitehr a ‘table’ or ‘timetable’ array, or an object
...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 587
 -- 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: 80
True if input is a ‘timetable’ array or other timetable-like type, false
...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 918
 -- 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: 80
Create a ‘duration’ X milliseconds long, or get the milliseconds in a
‘...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 122
 -- 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: 77
Create a ‘duration’ X hours long, or get the hours in a ‘duration’ X.



# 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: 489
 -- 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: 776
 -- 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: 362
 -- 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: 80
Create a ‘duration’ X seconds long, or get the seconds in a ‘duration...



# 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: 955
 -- 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: 657
 -- 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: 900
 -- 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: 852
 -- 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: 581
 -- 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: 601
 -- 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: 565
 -- 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: 77
Create a ‘duration’ X years long, or get the years in a ‘duration’ X.





