octave-nkf: doc/interpreter/dynamic.txi comparison

comparison doc/interpreter/dynamic.txi @ 7081:503001863427

[project @ 2007-10-31 01:08:14 by jwe]

author	jwe
date	Wed, 31 Oct 2007 01:09:28 +0000
parents	fd42779a8428
children	81bed50b9feb

comparison

equal deleted inserted replaced

-:7e465260a48f
+:503001863427
 @subsection Character Strings in Oct-Files
 In Octave a character string is just a special @code{Array} class.
 Consider the example
-@examplefile{stringdemo.cc}
+@longexamplefile{stringdemo.cc}
 An example of the of the use of this function is
 @example
 @group
 @code{octave_value} contains a single or double quoted string an example is
 @example
 @group
 if (args(0).is_sq_string ())
-octave_stdout << "First argument is a singularly quoted string\n";
+octave_stdout <<
+"First argument is a singularly quoted string\n";
 else if (args(0).is_dq_string ())
-octave_stdout << "First argument is a doubly quoted string\n";
+octave_stdout <<
+"First argument is a doubly quoted string\n";
 @end group
 @end example
 Note however, that both types of strings are represented by the
 @code{charNDArray} type, and so when assigning to an
 with the pair consisting of a @code{std::string} and an octave
 @code{Cell} variable.
 A simple example demonstrating the use of structures within oct-files is
-@examplefile{structdemo.cc}
+@longexamplefile{structdemo.cc}
 An example of its use is
 @example
 @group
 ii++;
 @}
 @}
 sm.cidx(j+1) = ii;
 @}
-sm.maybe_compress ();  // If don't know a-priori the final no of nz.
+sm.maybe_compress ();  // If don't know a-priori
+// the final no of nz.
 @end group
 @end example
 @noindent
 which is probably the most efficient means of creating the sparse matrix.
 ii++;
 @}
 @}
 sm.cidx(j+1) = ii;
 @}
-sm.maybe_mutate ();  // If don't know a-priori the final no of nz.
+sm.maybe_mutate ();  // If don't know a-priori
+// the final no of nz.
 @end group
 @end example
 Note that both increasing and decreasing the number of non-zero elements in
 a sparse matrix is expensive, as it involves memory reallocation.  Also as
 @example
 @group
 octave_value_list retval;
 SparseMatrix sm = args(0).sparse_matrix_value ();
-SparseComplexMatrix scm = args(1).sparse_complex_matrix_value ();
+SparseComplexMatrix scm =
+args(1).sparse_complex_matrix_value ();
 SparseBoolMatrix sbm = args(2).sparse_bool_matrix_value ();
 @dots{}
 retval(2) = sbm;
 retval(1) = scm;
 retval(0) = sm;
 the first is a string representing the variable name to obtain.  The
 second argument is a boolean argument specifying what to do in the case
 that no global variable of the desired name is found.  An example of the
 use of these two functions is
-@examplefile{globaldemo.cc}
+@longexamplefile{globaldemo.cc}
 An example of its use is
 @example
 @group
 @end enumerate
 The example below demonstrates an example that accepts all four means of
 passing a function to an oct-file.
-@examplefile{funcdemo.cc}
+@longexamplefile{funcdemo.cc}
 The first argument to this demonstration is the user supplied function
 and the following arguments are all passed to the user function.
 @example
 segmentation fault.
 An example of the inclusion of a Fortran function in an oct-file is
 given in the following example, where the C++ wrapper is
-@examplefile{fortdemo.cc}
+@longexamplefile{fortdemo.cc}
 @noindent
 and the fortran function is
-@examplefile{fortsub.f}
+@longexamplefile{fortsub.f}
 This example demonstrates most of the features needed to link to an
 external Fortran function, including passing arrays and strings, as well
 as exception handling.  An example of the behavior of this function is
 purposes of parameter checking.  These include the methods of the
 octave_value class like @code{is_real_matrix}, etc, but equally include
 more specialized functions.  Some of the more common ones are
 demonstrated in the following example
-@examplefile{paramdemo.cc}
+@longexamplefile{paramdemo.cc}
 @noindent
 and an example of its use is
 @example
 can also be used in oct-files.  In conjunction with the exception
 handling of Octave, it is important to enforce that certain code is run
 to allow variables, etc to be restored even if an exception occurs.  An
 example of the use of this mechanism is
-@examplefile{unwinddemo.cc}
+@longexamplefile{unwinddemo.cc}
 As can be seen in the example
 @example
 @group
 @example
 @group
 DEFUN_DLD (do_what_i_want, args, nargout,
 "-*- texinfo -*-\n\
 @@deftypefn @{Function File@} @{@} do_what_i_say (@@var@{n@})\n\
-A function that does what the user actually wants rather than what\n\
+A function that does what the user actually wants rather\n\
-they requested.\n\
+than what they requested.\n\
 @@end deftypefn")
 @{
 @dots{}
 @}
 @end group
 An example that demonstration how to work with arbitrary real or complex
 double precision arrays is given by the file @file{mypow2.c} as given
 below.
-@examplefile{mypow2.c}
+@longexamplefile{mypow2.c}
 @noindent
 with an example of its use
 @example
 @result{} 1
 @end group
 @end example
-The example above uses the @code{mxGetNumberOfElements},
+The example above uses @code{mxGetDimensions},
-@code{mxGetNumberOfDimensions} and @code{mxGetDimensions}, to work with
+@code{mxGetNumberOfElements}, @code{mxGetNumberOfDimensions}, to work with
 the dimensional parameters of multi-dimensional arrays.  The also exists
 the functions @code{mxGetM}, and @code{mxGetN} that probe the number of
 rows and columns in a matrix.
 @node Character Strings in Mex-Files
 quoted strings within Octave, there is perhaps less complexity in the
 use of strings and character matrices in mex-files.  An example of their
 use, that parallels the demo in @file{stringdemo.cc}, is given in the
 file @file{mystring.c}, as seen below.
-@examplefile{mystring.c}
+@longexamplefile{mystring.c}
 @noindent
 An example of its expected output is
 @example
 @code{mxCreateStructMatrix}, which creates a structure array with a two
 dimensional matrix, or @code{mxCreateStructArray}.
 @example
 @group
-mxArray *mxCreateStructArray (int ndims, int *dims, int num_keys,
+mxArray *mxCreateStructArray (int ndims, int *dims,
+int num_keys,
 const char **keys);
-mxArray *mxCreateStructMatrix (int rows, int cols, int num_keys,
+mxArray *mxCreateStructMatrix (int rows, int cols,
+int num_keys,
 const char **keys);
 @end group
 @end example
 Accessing the fields of the structure can then be performed with the
 @code{mxGetField} and @code{mxSetField} or alternatively with the
 @code{mxGetFieldByNumber} and @code{mxSetFieldByNumber} functions.
 @example
 @group
-mxArray *mxGetField (const mxArray *ptr, mwIndex index, const char *key);
+mxArray *mxGetField (const mxArray *ptr, mwIndex index,
+const char *key);
 mxArray *mxGetFieldByNumber (const mxArray *ptr,
 mwIndex index, int key_num);
 void mxSetField (mxArray *ptr, mwIndex index,
 const char *key, mxArray *val);
 void mxSetFieldByNumber (mxArray *ptr, mwIndex index,
 includes a Cell Array per field of the structure.
 An example that demonstrates the use of structures in mex-file can be
 found in the file @file{mystruct.c}, as seen below
-@examplefile{mystruct.c}
+@longexamplefile{mystruct.c}
 An example of the behavior of this function within Octave is then
 @example
 @group
-a(1).f1 = "f11"; a(1).f2 = "f12"; a(2).f1 = "f21"; a(2).f2 = "f22";
+a(1).f1 = "f11"; a(1).f2 = "f12";
+a(2).f1 = "f21"; a(2).f2 = "f22";
 b = mystruct(a)
 @result{} field f1(0) = f11
 field f1(1) = f21
 field f2(0) = f12
 field f2(1) = f22
 It is also possible call other Octave functions from within a mex-file
 using @code{mexCallMATLAB}.  An example of the use of
 @code{mexCallMATLAB} can be see in the example below
-@examplefile{myfeval.c}
+@longexamplefile{myfeval.c}
 If this code is in the file @file{myfeval.c}, and is compiled to
 @file{myfeval.mex}, then an example of its use is
 @example

Mercurial > octave-nkf

comparison doc/interpreter/dynamic.txi @ 7081:503001863427