# doc-cache created by Octave 10.1.0
# name: cache
# type: cell
# rows: 3
# columns: 11
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
dispstrs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1041
 -- Function File: STRS = dispstrs (X)

     Create display strings for arbitrary array.

     ‘dispstrs’ converts arbitrary inputs to displayable strings
     suitable for user presentation.  Each element of the input array is
     converted to one string in the output, which is returned as a
     cellstr the same size as the input.

     Many programming languages provide general, polymorphic string
     conversion operations, so you can call them on any input and expect
     to get something useful.  For example, ‘toString’ in Java or ‘str’
     in Python.  Octave lacks that.  dispstrs intends to fill that gap.
     It provides useful conversion implementations for many of Octave’s
     built-in types, and the intention is that user-defined classes can
     provide their own ‘dispstrs’ methods to override it.

     Returns a cellstr the same size as x.  Note that this is strictly
     true: if you pass in a string as a char row vector, you will get
     back each individual character as a separate string.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Create display strings for arbitrary array.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 338
 -- Function File: empty_obj = emptyobj (obj)
     Create an empty object from a nonempty one.

     This is a hack to create an empty object, since ‘repmat(obj, [0
     0])’ doesn’t work as of Octave 5.1.  All it does is ‘obj([])’, but
     having a function that does this lets you use it inline in
     one-liner expressions.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Create an empty object from a nonempty one.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 305
 -- Function File: OUT = makeItBeA (X, TYPE)

     Converts input to given type if it is not one already.

     Ensures that the input x is of the given type.  If it is not
     already that type (as indicated by ‘isa (x, type))’, it is
     converted by calling the one-argument constructor for type.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Converts input to given type if it is not one already.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 371
 -- Function File: X = mustBeA (X, TYPE)

     Requires that input is of a given type.

     Raises an error if the input X is not of the specified TYPE or a
     subclass.

     LABEL is an optional input that determines how the input will be
     described in error messages.  If not supplied, INPUTNAME (1) is
     used, and if that is empty, it falls back to "input".


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Requires that input is of a given type.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 448
 -- Function File: X = mustBeCharvec (X, LABEL)

     Requires that input is a char row vector (Octave’s normal string
     representation).

     Raises an error if the input X is not a char row vector.

     LABEL is an optional input that determines how the input will be
     described in error messages.  If not supplied, INPUTNAME (1) is
     used, and if that is empty, it falls back to "input".

     Returns X unmodified for convenience.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Requires that input is a char row vector (Octave’s normal string
representa...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 425
 -- Function File: X = mustBeNonempty (X, LABEL)

     Requires that input is nonempty.

     Raises an error if the input X is not empty, as determined by ‘!
     isempty (x)’.

     LABEL is an optional input that determines how the input will be
     described in error messages.  If not supplied, INPUTNAME (1) is
     used, and if that is empty, it falls back to "input".

     Returns X unmodified, for convenience.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Requires that input is nonempty.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 382
 -- Function File: X = mustBeScalar (X, LABEL)

     Requires that input is scalar.

     Raises an error if the input ‘x’ is not scalar, as determined by
     ‘isscalar (x)’.

     LABEL is an optional input that determines how the input will be
     described in error messages.  If not supplied, INPUTNAME (1) is
     used, and if that is empty, it falls back to "input".


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Requires that input is scalar.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 279
 -- Function File: OBJ = objdel (OBJ, IX)

     Deletes selected elements from an object array.

     This function just papers over the fact that Octave does not
     support the ‘obj(ix) = []’ element deletion syntax for objects.

     IX may be a logical or numeric index.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Deletes selected elements from an object array.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 406
 -- Function File: OUT = objvcat (X, ...)

     Concatenates object array vectors.

     This function just papers over the fact that Octave does not
     support the ‘[obj1 obj2]’ concatenation syntax for objects.

     X may be an object of any type.  The additional inputs may be any
     type that is assignment compatible with X, but they will typically
     just be more objects of the same type.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Concatenates object array vectors.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10160
 -- pkj COMMAND PKG_NAME
 -- pkj COMMAND [OPTION ...] PKG_NAME
 -- [OUT1, ...] = pkj (COMMAND, ... )
     Manage or query packages (groups of add-on functions) for Octave.

     pkj is the main command interface for the Packajoozle package
     manager.

     Different actions are available depending on the value of COMMAND,
     the additional options supplied, and the return arguments captured.

     Please note, pkj is a work in progress.  Some of the commands
     listed below will not actually work.  If you have trouble with any
     of them, please post a bug report at
     https://github.com/apjanke/octave-packajoozle/issues.

     Available commands:

     ‘install’
          Install named packages.  For example,

               pkj install image-1.0.0.tar.gz

          installs the package found in the file ‘image-1.0.0.tar.gz’.
          The file containing the package can be a URL, e.g.

               pkj install 'http://somewebsite.org/image-1.0.0.tar.gz'

          installs the package found in the given URL. This requires an
          internet connection and the cURL library.

          If the named file does not exist, it is checked against the
          list of Octave Forge packages, and if it’s a Forge package,
          that is used.  For Forge packages, you may also give version
          selectors, like so:

               pkj install io@2.4.12
               pkj install io@<2.2
               pkj install io@>=2.0.0

          _Security risk_: no verification of the package is performed
          before the installation.  It has the same security issues as
          manually downloading the package from the given URL and
          installing it.

          _No support_: the GNU Octave community is not responsible for
          packages installed from foreign sites.  For support or for
          reporting bugs you need to contact the maintainers of the
          installed package directly (see the ‘DESCRIPTION’ file of the
          package).

          The OPTION arguments can contain options that affect the
          manner in which a package is installed.  These options can be
          one or more of:

          ‘-nodeps’
               The package manager will disable dependency checking.
               With this option it is possible to install a package even
               when it depends on another package which is not installed
               on the system.  *Use this option with care.*

          ‘-user’
               A user-local installation (package available only to
               current user) is selected.  This is usually the default,
               unless you have a custom prefix defined.

          ‘-global’
               A global installation (package available to all users) is
               selected.

          ‘-place <name>’
               The package is installed to the selected place.  This can
               place name may be one of "global", "user", "custom", or
               the name of a place that was added with the ‘add-place’
               command.

          ‘-forge’
               Forces the argument to be interpreted as a package from
               the Octave Forge repository.  This requires an internet
               connection and the cURL library.  Usually, this is
               detected by default so the -forge option is not required.

          ‘-file’
               Forces the argument to be interpreted as a path to a
               local file.  Usually, this is detected by default so the
               -file option is not required.

          ‘-url’
               Forces the argument to be interpreted as a URL. Usually,
               this is detected by default so the -url option is not
               required.

                    pkj install -forge io
                    pkj install -forge io@2.4.9
                    pkj install -forge symbolic@<=2.6.5
                    pkj install -forge io statistics financial@0.5.1

               _Security risk_: no verification of the package is
               performed before the installation.  There are no
               signature for packages, or checksums to confirm the
               correct file was downloaded.  It has the same security
               issues as manually downloading the package from the
               Octave Forge repository and installing it.

          ‘-verbose’
               The package manager will print the output of all actions
               as they are performed.

     ‘update’
          Check installed Octave Forge packages against the repository
          and update any outdated items.  This requires an internet
          connection and the cURL library.  Usage:

               pkj update

          To update a single package use ‘pkj install -forge <name>’.

     ‘uninstall’
          Uninstall named packages.  For example,

               pkj uninstall image

          removes the ‘image’ package from the default installation
          place.  If another installed package depends on the ‘image’
          package an error will be issued.  The package can be
          uninstalled anyway by using the ‘-nodeps’ option.

               pkj uninstall -global image

          removes the ‘image’ package from the global installation
          place.

     ‘load’
          Add named packages to the path.  After loading a package it is
          possible to use the functions provided by the package.  For
          example,

               pkj load image
               pkj load image@2.8.1

          adds the ‘image’ package to the path.

     ‘unload’
          Remove named packages from the path.  After unloading a
          package it is no longer possible to use the functions provided
          by the package.

     ‘list’
          Show the list of currently installed packages.  For example,

               pkj list

          will produce a short report with the package name, version,
          and installation directory for each installed package.  Supply
          a package name to limit reporting to a particular package.
          For example:

               pkj list image

          If a single return argument is requested then ‘pkj’ returns a
          cell array where each element is a structure with information
          on a single package.

               installed_packages = pkj ("list")

          If two output arguments are requested ‘pkj’ splits the list of
          installed packages into those which were installed by the
          current user, and those which were installed by the system
          administrator.

               [user_packages, system_packages] = pkj ("list")

          The "-forge" option lists packages available at the Octave
          Forge repository.  This requires an internet connection and
          the cURL library.  For example:

               oct_forge_pkgs = pkj ("list", "-forge")

     ‘describe’
          Show a short description of installed packages.  With the
          option "-verbose" also list functions provided by the package.
          For example,

               pkj describe -verbose

          will describe all installed packages and the functions they
          provide.  Display can be limited to a set of packages:

               ## describe control and signal packages
               pkj describe control signal

          If one output is requested a cell of structure containing the
          description and list of functions of each package is returned
          as output rather than printed on screen:

               desc = pkj ("describe", "secs1d", "image")

          If any of the requested packages is not installed, ‘pkj’
          returns an error, unless a second output is requested:

               [desc, flag] = pkj ("describe", "secs1d", "image")

          FLAG will take one of the values "Not installed", "Loaded", or
          "Not loaded" for each of the named packages.

     ‘contents’
          List contents of named packages.  For example,

               pkj contents image

     ‘test’
          Test the named packages

               pkj test io nan

     ‘default-place’
          Set the default place where packages will be installed to or
          uninstalled from.  The place is identified by name, and may be
          one of ‘"global"’, ‘"user"’, or (if you have one defined via
          ‘pkg’), ‘"custom"’.

          The duration of this setting is an Octave session, or until
          you ‘"clear classes"’.

          If you do not set a default place with ‘default-place’, the
          default default place is either ‘"custom"’ (if you have one
          defined), or ‘"user"’.

               pkj default-place global
               pkj default-place user

     ‘build’
          Build a binary form of a package or packages.  The binary file
          produced will itself be an Octave package that can be
          installed normally with ‘pkj’.  The form of the command to
          build a binary package is:

               pkj build builddir image-1.0.0.tar.gz ...

          where ‘builddir’ is the name of a directory where the
          temporary installation will be produced and the binary
          packages will be found.  The options ‘-verbose’ and ‘-nodeps’
          are respected, while all other options are ignored.

     ‘rebuild’
          Rebuild the package database from the installed directories.
          This can be used in cases where the package database has been
          corrupted.

     ‘review’
          Review a package distribution tarball to see if it meets
          Octave Forge’s quality standards.

               pkj review strings-1.2.0.tar.gz
               pkj review /path/to/my/local/clone/of/octave-strings
               pkj review strings@1.2.0
               pkj review -verbose strings-1.2.0.tar.gz
               # Abort on first error
               pkj review -verbose -fail-fast strings-1.2.0.tar.gz

     See also: ver, news.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Manage or query packages (groups of add-on functions) for Octave.



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


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

     Format an array size for display.

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

     Returns a char row vector.


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





