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

comparison doc/interpreter/dynamic.txi @ 10828:322f43e0e170

Grammarcheck .txi documentation files.

author	Rik <octave@nomad.inbox5.com>
date	Wed, 28 Jul 2010 12:45:04 -0700
parents	3140cb7a05a1
children	a4f482e66b65

comparison

equal deleted inserted replaced

-:228cd18455a6
+:322f43e0e170
 address ask yourself
 @itemize @bullet
 @item
 Can I get the same functionality using the Octave scripting language only?
 @item
 Is it thoroughly optimized Octave code?  Vectorization of Octave code,
 doesn't just make it concise, it generally significantly improves its
 performance.  Above all, if loops must be used, make sure that the
 allocation of space for variables takes place outside the loops using an
 assignment to a matrix of the right size, or zeros.
 @item
 Does it make as much use as possible of existing built-in library
 routines?  These are highly optimized and many do not carry the overhead
 of being interpreted.
 @item
 Does writing a dynamically linked function represent useful investment
 of your time, relative to staying in Octave?
 @end itemize
 The basic command to build oct-files is @code{mkoctfile} and it can be
 call from within octave or from the command line.
 @DOCSTRING(mkoctfile)
-Consider the short example
+Consider the short example:
 @example
 @group
 @EXAMPLEFILE(helloworld.cc)
 @end group
 The macro that defines the entry point into the dynamically loaded
 function is @w{@code{DEFUN_DLD}}.  This macro takes four arguments, these being
 @enumerate 1
 @item The function name as it will be seen in Octave,
 @item The list of arguments to the function of type @code{octave_value_list},
 @item The number of output arguments, which can and often is omitted if
 not used, and
 @item The string that will be seen as the help text of the function.
 @end enumerate
 The return type of functions defined with @w{@code{DEFUN_DLD}} is always
 @code{octave_value_list}.
 There are a couple of important considerations in the choice of function
 name.  Firstly, it must be a valid Octave function name and so must be a
 sequence of letters, digits and underscores, not starting with a
 digit.  Secondly, as Octave uses the function name to define the filename
-it attempts to find the function in, the function name in the @w{@code{DEFUN_DLD}}
+it attempts to find the function in, the function name in the
-macro must match the filename of the oct-file.  Therefore, the above
+@w{@code{DEFUN_DLD}} macro must match the filename of the oct-file.  Therefore,
-function should be in a file @file{helloworld.cc}, and it should be
+the above function should be in a file @file{helloworld.cc}, and it should be
 compiled to an oct-file using the command
 @example
 mkoctfile helloworld.cc
 @end example
 matrix types
 @table @code
 @item Matrix
 A double precision matrix class defined in dMatrix.h,
 @item ComplexMatrix
 A complex matrix class defined in CMatrix.h, and
 @item BoolMatrix
 A boolean matrix class defined in boolMatrix.h.
 @end table
 These are the basic two-dimensional matrix types of octave.  In
 being
 @table @code
 @item NDArray
 A double precision array class defined in @file{dNDArray.h}
 @item ComplexNDarray
 A complex array class defined in @file{CNDArray.h}
 @item boolNDArray
 A boolean array class defined in @file{boolNDArray.h}
 @item int8NDArray
 @itemx int16NDArray
 @itemx int32NDArray
 @itemx int64NDArray
 8, 16, 32 and 64-bit signed array classes defined in
 @file{int8NDArray.h}, @file{int16NDArray.h}, etc.
 @item uint8NDArray
 @itemx uint16NDArray
 @itemx uint32NDArray
 @itemx uint64NDArray
 8, 16, 32 and 64-bit unsigned array classes defined in
 @example
 Matrix a;
 @end example
 This can be used on all matrix and array types
 @item
 Define the dimensions of the matrix or array with a dim_vector.  For
 example
 @example
 Matrix a (dv);
 @end group
 @end example
 This can be used on all matrix and array types
 @item
-Define the number of rows and columns in the matrix.  For example
+Define the number of rows and columns in the matrix.  For example:
 @example
 Matrix a (2, 2)
 @end example
 @end itemize
 These types all share a number of basic methods and operators, a
 selection of which include
-@deftypefn Method T& {operator ()} (octave_idx_type)
+@deftypefn  Method T& {operator ()} (octave_idx_type)
 @deftypefnx Method T& elem (octave_idx_type)
 The @code{()} operator or @code{elem} method allow the values of the
 matrix or array to be read or set.  These can take a single argument,
 which is of type @code{octave_idx_type}, that is the index into the matrix or
 array.  Additionally, the matrix type allows two argument versions of the
 @node Character Strings in Oct-Files
 @subsection Character Strings in Oct-Files
 In Octave a character string is just a special @code{Array} class.
-Consider the example
+Consider the example:
 @example
 @EXAMPLEFILE(stringdemo.cc)
 @end example
 @end group
 @end example
 Note however, that both types of strings are represented by the
 @code{charNDArray} type, and so when assigning to an
-@code{octave_value}, the type of string should be specified.  For example
+@code{octave_value}, the type of string should be specified.  For example:
 @example
 @group
 octave_value_list retval;
 charNDArray c;
 user.
 @table @code
 @item SparseMatrix
 A double precision sparse matrix class
 @item SparseComplexMatrix
 A complex sparse matrix class
 @item SparseBoolMatrix
 A boolean sparse matrix class
 @end table
 All of these classes inherit from the @code{Sparse<T>} template class,
 Most of the same operators and functions on sparse matrices that are
 available from the Octave are equally available with oct-files.
 The basic means of extracting a sparse matrix from an @code{octave_value}
 and returning them as an @code{octave_value}, can be seen in the
-following example
+following example.
 @example
 @group
 octave_value_list retval;
 There are also many ways in which a function might be passed.  It might
 be passed as one of
 @enumerate 1
 @item Function Handle
 @item Anonymous Function Handle
 @item Inline Function
 @item String
 @end enumerate
 The example below demonstrates an example that accepts all four means of
 passing a function to an oct-file.
 There are several functions within Octave that might be useful for the
 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
+demonstrated in the following example.
 @example
 @EXAMPLEFILE(paramdemo.cc)
 @end example
 @noindent
-and an example of its use is
+An example of its use is:
 @example
 @group
 paramdemo ([1, 2, NaN, Inf])
 @result{} Properties of input array:
 Another important feature of Octave is its ability to react to the user
 typing @kbd{Control-C} even during calculations.  This ability is based on the
 C++ exception handler, where memory allocated by the C++ new/delete
 methods are automatically released when the exception is treated.  When
 writing an oct-file, to allow Octave to treat the user typing @kbd{Control-C},
-the @w{@code{OCTAVE_QUIT}} macro is supplied.  For example
+the @w{@code{OCTAVE_QUIT}} macro is supplied.  For example:
 @example
 @group
 for (octave_idx_type i = 0; i < a.nelem (); i++)
 @{
 b.elem(i) = 2. * a.elem(i);
 @}
 @end group
 @end example
-The presence of the @w{@code{OCTAVE_QUIT}} macro in the inner loop allows Octave to
+The presence of the @w{@code{OCTAVE_QUIT}} macro in the inner loop allows
-treat the user request with the @kbd{Control-C}.  Without this macro, the user
+Octave to treat the user request with the @kbd{Control-C}.  Without this macro,
-must either wait for the function to return before the interrupt is
+the user must either wait for the function to return before the interrupt is
 processed, or press @kbd{Control-C} three times to force Octave to exit.
-The @w{@code{OCTAVE_QUIT}} macro does impose a very small speed penalty, and so for
+The @w{@code{OCTAVE_QUIT}} macro does impose a very small speed penalty, and so
-loops that are known to be small it might not make sense to include
+for loops that are known to be small it might not make sense to include
 @w{@code{OCTAVE_QUIT}}.
 When creating an oct-file that uses an external libraries, the function
 might spend a significant portion of its time in the external
-library.  It is not generally possible to use the @w{@code{OCTAVE_QUIT}} macro in
+library.  It is not generally possible to use the @w{@code{OCTAVE_QUIT}} macro
-this case.  The alternative in this case is
+in this case.  The alternative in this case is
 @example
 @group
 BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
 @dots{}  some code that calls a "foreign" function @dots{}
 @example
 @EXAMPLEFILE(unwinddemo.cc)
 @end example
-As can be seen in the example
+As can be seen in the example:
 @example
 @group
 unwinddemo (1, 0)
 @result{} Inf
 help strings within oct-files.
 The major issue is that the help string will typically be longer than a
 single line of text, and so the formatting of long help strings need to
 be taken into account.  There are several manners in which to treat this
-issue, but the most common is illustrated in the following example
+issue, but the most common is illustrated in the following example,
 @example
 @group
 DEFUN_DLD (do_what_i_want, args, nargout,
 "-*- texinfo -*-\n\
 with Octave is that the header file "matrix.h" is implicitly included
 through the inclusion of "mex.h".  This is to avoid a conflict with the
 Octave file "Matrix.h" with operating systems and compilers that don't
 distinguish between filenames in upper and lower case
-Consider the short example
+Consider the short example:
 @example
 @group
 @EXAMPLEFILE(firstmexdemo.c)
 @end group
 @code{mxGetPr}.  As the mex interface assumes that the real and imaginary
 parts of a complex array are stored separately, there is an equivalent
 function @code{mxGetPi} that get the imaginary part.  Both of these
 functions are for use only with double precision matrices.  There also
 exists the generic function @code{mxGetData} and @code{mxGetImagData}
-that perform the same operation on all matrix types.  For example
+that perform the same operation on all matrix types.  For example:
 @example
 @group
 mxArray *m;
 mwSize *dims;

Mercurial > hg > octave-nkf

comparison doc/interpreter/dynamic.txi @ 10828:322f43e0e170