home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / octave-1.1.1p1-src.tgz / tar.out / fsf / octave / doc / FAQ.info (.txt) < prev    next >
GNU Info File  |  1996-09-28  |  29KB  |  584 lines
  1. This is Info file FAQ.info, produced by Makeinfo-1.55 from the input
  2. file FAQ.texi.
  3. File: FAQ.info,  Node: Top,  Next: What is Octave?,  Prev: (dir),  Up: (dir)
  4. Preface
  5. *******
  6.    This is a list of frequently asked questions (FAQ) for Octave users.
  7.    Some information in this FAQ was developed for earlier versions of
  8. Octave and may now be obsolete.
  9.    I'm looking for new questions (*with* answers), better answers, or
  10. both.  Please send suggestions to bug-octave@che.utexas.edu.  If you
  11. have general questions about Octave, or need help for something that is
  12. not covered by the FAQ, please use the help-octave@che.utexas.edu
  13. mailing list.
  14.    This FAQ is intended to supplement, not replace, the Octave manual.
  15. Before posting a question to the hlpe-octave mailing list, you should
  16. first check to see if the topic is covered in the manual.
  17. * Menu:
  18. * What is Octave?::
  19. * Version 1.1.0::
  20. * Octave Features::
  21. * Documentation::
  22. * Getting Octave::
  23. * Installation::
  24. * Common problems::
  25. * Getting additional help::
  26. * Bug reports::
  27. * MATLAB compatibility::
  28. * Index::
  29. File: FAQ.info,  Node: What is Octave?,  Next: Version 1.1.0,  Prev: Top,  Up: Top
  30. What is Octave?
  31. ***************
  32.    Octave is a high-level interactive language, primarily intended for
  33. numerical computations that is mostly compatible with MATLAB.(1)
  34.    Octave can do arithmetic for real and complex scalars and matrices,
  35. solve sets of nonlinear algebraic equations, integrate functions over
  36. finite and infinite intervals, and integrate systems of ordinary
  37. differential and differential-algebraic equations.
  38.    Octave uses the GNU readline library to handle reading and editing
  39. input.  By default, the line editing commands are similar to the cursor
  40. movement commands used by GNU Emacs, and a vi-style line editing
  41. interface is also available.  At the end of each session, the command
  42. history is saved, so that commands entered during previous sessions are
  43. not lost.
  44.    The Octave distribution includes a 200+ page Texinfo manual.  Access
  45. to the complete text of the manual is available via the help command at
  46. the Octave prompt.
  47.    Two and three dimensional plotting is fully supported using gnuplot.
  48.    The underlying numerical solvers are currently standard Fortran ones
  49. like Lapack, Linpack, Odepack, the Blas, etc., packaged in a library of
  50. C++ classes.  If possible, the Fortran subroutines are compiled with
  51. the system's Fortran compiler, and called directly from the C++
  52. functions.  If that's not possible, you can still compile Octave if you
  53. have the free Fortran to C translator f2c.
  54.    Octave is also free software; you can redistribute it and/or modify
  55. it under the terms of the GNU General Public License as published by the
  56. Free Software Foundation.
  57.    ---------- Footnotes ----------
  58.    (1)  MATLAB is a registered trademark of The MathWorks, Inc.
  59. File: FAQ.info,  Node: Version 1.1.0,  Next: Octave Features,  Prev: What is Octave?,  Up: Top
  60. What's new in version 1.1.0 of Octave
  61. *************************************
  62.    The long-awaited version 1.1.0 of Octave has now been released.  Many
  63. bugs have been fixed and lots of new features added.  Octave is now much
  64. more compatible with MATLAB.
  65.    Version 1.1.0 fixes many bugs, but as with any "x.y.0" release there
  66. will be a few glitches.  You can expect a 1.1.1 shortly.  You can help
  67. contribute to the quality of Octave by trying it out and submitting bug
  68. reports where you find them.
  69.    A list of user-visible changes in recent versions of Octave may be
  70. found in the file NEWS, distributed in both source and binary releases
  71. of Octave.
  72. File: FAQ.info,  Node: Octave Features,  Next: Documentation,  Prev: Version 1.1.0,  Up: Top
  73. What features are unique to Octave?
  74. ***********************************
  75. * Menu:
  76. * Command and variable name completion::
  77. * Command history::
  78. * Data structures::
  79. * Short-circuit boolean operators::
  80. * Increment and decrement operators::
  81. * Unwind-protect::
  82. * Variable-length argument lists::
  83. * Variable-length return lists::
  84. * Built-in ODE and DAE solvers::
  85. File: FAQ.info,  Node: Command and variable name completion,  Next: Command history,  Prev: Octave Features,  Up: Octave Features
  86. Command and variable name completion
  87. ====================================
  88.    Typing a TAB character (ASCII code 9) on the command line causes
  89. Octave to attempt to complete variable, function, and file names.
  90. Octave uses the text before the cursor as the initial portion of the
  91. name to complete.
  92.    For example, if you type `fu' followed by TAB at the Octave prompt,
  93. Octave will complete the rest of the name `function' on the command
  94. line (unless you have other variables or functions defined that begin
  95. with the characters `fu').  If there is more than one possible
  96. completion, Octave will ring the terminal bell to let you know that your
  97. initial sequence of characters is not enough to specify a unique name.
  98. To complete the name, you may either edit the initial character sequence
  99. (usually adding more characters until completion is possible) or type
  100. another TAB to cause Octave to display the list of possible completions.
  101. File: FAQ.info,  Node: Command history,  Next: Data structures,  Prev: Command and variable name completion,  Up: Octave Features
  102. Command history
  103. ===============
  104.    When running interactively, Octave saves the commands you type in an
  105. internal buffer so that you can recall and edit them.  Emacs and vi
  106. editing modes are available with Emacs keybindings enabled by default.
  107.    When Octave exits, the current command history is saved to the file
  108. `~/.octave_hist', and each time Octave starts, it inserts the contents
  109. of the `~/.octave_hist' file in the history list so that it is easy to
  110. begin working where you left off.
  111. File: FAQ.info,  Node: Data structures,  Next: Short-circuit boolean operators,  Prev: Command history,  Up: Octave Features
  112. Data structures
  113. ===============
  114.    Octave includes a limited amount of support for organizing data in
  115. structures.  The current implementation uses an associative array with
  116. indices limited to strings, but the syntax is more like C-style
  117. structures.  Here are some examples of using data structures in Octave.
  118.    * Elements of structures can be of any value type.
  119.           octave:1> x.a = 1; x.b = [1, 2; 3, 4]; x.c = "string";
  120.           octave:2> x.a
  121.           x.a = 1
  122.           octave:3> x.b
  123.           x.b =
  124.           
  125.             1  2
  126.             3  4
  127.           
  128.           octave:4> x.c
  129.           x.c = string
  130.    * Structures may be copied.
  131.           octave:1> y = x
  132.           y =
  133.           
  134.           <structure: a b c>
  135.    * Structure elements may reference other structures.
  136.           octave:1> x.b.d = 3
  137.           x.b.d = 3
  138.           octave:2> x.b
  139.           x.b =
  140.           
  141.           <structure: d>
  142.           
  143.           octave:3> x.b.d
  144.           x.b.d = 3
  145.    * Functions can return structures.
  146.           octave:1> function y = f (x)
  147.           > y.re = real (x);
  148.           > y.im = imag (x);
  149.           > endfunction
  150.           
  151.           octave:2> f (rand + rand*I);
  152.           ans =
  153.           
  154.           <structure: im re>
  155.           
  156.           octave:3> ans.im, ans.re
  157.           ans.im = 0.93411
  158.           ans.re = 0.56234
  159.    * Function return lists can include structure elements, and they may
  160.      be indexed like any other variable.
  161.           octave:1> [x.u, x.s(2:3,2:3), x.v] = svd ([1, 2; 3, 4])
  162.           x.u =
  163.           
  164.             -0.40455  -0.91451
  165.             -0.91451   0.40455
  166.           
  167.           x.s =
  168.           
  169.             0.00000  0.00000  0.00000
  170.             0.00000  5.46499  0.00000
  171.             0.00000  0.00000  0.36597
  172.           
  173.           x.v =
  174.           
  175.             -0.57605   0.81742
  176.             -0.81742  -0.57605
  177.           
  178.           octave:8> x
  179.           x =
  180.           
  181.           <structure: s u v>
  182.    * You can also use the function `is_struct' to determine whether a
  183.      given value is a data structure.  For example
  184.           is_struct (x)
  185.      returns 1 if the value of the variable X is a data structure.
  186.    This feature should be considered experimental, but you should
  187. expect it to work.  Suggestions for ways to improve it are welcome.
  188. File: FAQ.info,  Node: Short-circuit boolean operators,  Next: Increment and decrement operators,  Prev: Data structures,  Up: Octave Features
  189. Short-circuit boolean operators
  190. ===============================
  191.    Octave's `&&' and `||' logical operators are evaluated in a
  192. short-circuit fashion (like the corresponding operators in the C
  193. language) and work differently than the element by element operators
  194. `&' and `|'.
  195. File: FAQ.info,  Node: Increment and decrement operators,  Next: Unwind-protect,  Prev: Short-circuit boolean operators,  Up: Octave Features
  196. Increment and decrement operators
  197. =================================
  198.    Octave includes the C-like increment and decrement operators `++'
  199. and `--' in both their prefix and postfix forms.
  200.    For example, to pre-increment the variable X, you would write `++X'.
  201. This would add one to X and then return the new value of X as the
  202. result of the expression.  It is exactly the same as the expression `X
  203. = X + 1'.
  204.    To post-increment a variable X, you would write `X++'.  This adds
  205. one to the variable X, but returns the value that X had prior to
  206. incrementing it.  For example, if X is equal to 2, the result of the
  207. expression `X++' is 2, and the new value of X is 3.
  208.    For matrix and vector arguments, the increment and decrement
  209. operators work on each element of the operand.
  210.    It is not currently possible to increment index expressions.  For
  211. example, you might expect that the expression `V(4)++' would increment
  212. the fourth element of the vector V, but instead it results in a parse
  213. error.  This problem may be fixed in a future release of Octave.
  214. File: FAQ.info,  Node: Unwind-protect,  Next: Variable-length argument lists,  Prev: Increment and decrement operators,  Up: Octave Features
  215. Unwind-protect
  216. ==============
  217.    Octave supports a limited form of exception handling modelled after
  218. the unwind-protect form of Lisp.  The general form of an
  219. `unwind_protect' block looks like this:
  220.      unwind_protect
  221.        BODY
  222.      unwind_protect_cleanup
  223.        CLEANUP
  224.      end_unwind_protect
  225. Where BODY and CLEANUP are both optional and may contain any Octave
  226. expressions or commands.  The statements in CLEANUP are guaranteed to
  227. be executed regardless of how control exits BODY.
  228.    The `unwind_protect' statement is often used to reliably restore the
  229. values of global variables that need to be temporarily changed.
  230. File: FAQ.info,  Node: Variable-length argument lists,  Next: Variable-length return lists,  Prev: Unwind-protect,  Up: Octave Features
  231. Variable-length argument lists
  232. ==============================
  233.    Octave has a real mechanism for handling functions that take an
  234. unspecified number of arguments, so it is no longer necessary to place
  235. an upper bound on the number of optional arguments that a function can
  236. accept.
  237.    Here is an example of a function that uses the new syntax to print a
  238. header followed by an unspecified number of values:
  239.      function foo (heading, ...)
  240.        disp (heading);
  241.        va_start ();
  242.        while (--nargin)
  243.          disp (va_arg ());
  244.        endwhile
  245.      endfunction
  246.    Calling `va_start()' positions an internal pointer to the first
  247. unnamed argument and allows you to cycle through the arguments more than
  248. once.  It is not necessary to call `va_start()' if you do not plan to
  249. cycle through the arguments more than once.
  250.    The function `va_arg()' returns the value of the next available
  251. argument and moves the internal pointer to the next argument.  It is an
  252. error to call `va_arg()' when there are no more arguments available.
  253.    It is also possible to use the keyword ALL_VA_ARGS to pass all
  254. unnamed arguments to another function.
  255. File: FAQ.info,  Node: Variable-length return lists,  Next: Built-in ODE and DAE solvers,  Prev: Variable-length argument lists,  Up: Octave Features
  256. Variable-length return lists
  257. ============================
  258.    Octave also has a real mechanism for handling functions that return
  259. an unspecified number of values, so it is no longer necessary to place
  260. an upper bound on the number of outputs that a function can produce.
  261.    Here is an example of a function that uses the new syntax to produce
  262. `N' values:
  263.      function [...] = foo (n)
  264.        for i = 1:n
  265.          vr_val (i);
  266.        endfor
  267.      endfunction
  268. File: FAQ.info,  Node: Built-in ODE and DAE solvers,  Prev: Variable-length return lists,  Up: Octave Features
  269. Built-in ODE and DAE solvers
  270. ============================
  271.    Octave includes LSODE and DASSL for solving systems of stiff
  272. differential and differential-algebraic equations.  These functions are
  273. built in to the interpreter.
  274. File: FAQ.info,  Node: Documentation,  Next: Getting Octave,  Prev: Octave Features,  Up: Top
  275. What documentation exists for Octave?
  276. *************************************
  277.    The Octave distribution includes a 220+ page manual that is also
  278. distributed under the terms of the GNU GPL.
  279.    The Octave manual is intended to be a complete reference for Octave,
  280. but it is not a finished document.  If you have problems using it, or
  281. find that some topic is not adequately explained, indexed, or
  282. cross-referenced, please send a bug report to bug-octave@che.utexas.edu.
  283.    Because the Octave manual is written using Texinfo, the complete
  284. text of the Octave manual is also available on line using the GNU Info
  285. system via the GNU Emacs, info, or xinfo programs, or by using the
  286. `help -i' command to start the GNU info browser directly from the
  287. Octave prompt.
  288.    It is also possible to use WWW browsers such as Mosaic to read the
  289. Octave manual (or any other Info file) by using Roar Smith's info2www
  290. program to convert GNU Info files to HTML.  The source for info2www is
  291. available via anonymous ftp from ftp.che.utexas.edu in the directory
  292. `/pub/www'.
  293. File: FAQ.info,  Node: Getting Octave,  Next: Installation,  Prev: Documentation,  Up: Top
  294. Obtaining Source Code
  295. *********************
  296. * Menu:
  297. * Octave for Unix::
  298. * Octave for other platforms::
  299. * latest versions::
  300. File: FAQ.info,  Node: Octave for Unix,  Next: Octave for other platforms,  Prev: Getting Octave,  Up: Getting Octave
  301. How do I get a copy of Octave for Unix?
  302. =======================================
  303.    You can get Octave from a friend who has a copy, by anonymous FTP,
  304. or by ordering a tape or CD-ROM from the Free Software Foundation (FSF).
  305.    Octave was not developed by the FSF, but the FSF does distribute
  306. Octave, and the developers of Octave support the efforts of the FSF by
  307. encouraging users of Octave to order Octave on tape or CD directly from
  308. the FSF.
  309.    The FSF is a nonprofit organization that distributes software and
  310. manuals to raise funds for more GNU development.  Buying a tape or CD
  311. from the FSF contributes directly to paying staff to develop GNU
  312. software.  CD-ROMs cost $400 if an organization is buying, or $100 if an
  313. individual is buying.  Tapes cost around $200 depending on media type.
  314.    The FSF only makes new CD releases a few times a year, so if you are
  315. interested specifically in Octave, I recommend asking for the latest
  316. release on tape.
  317.    For more information about ordering from the FSF, contact
  318. gnu@prep.ai.mit.edu, phone (617) 876-3296 or anonymous ftp file
  319. `/pub/gnu/GNUinfo/ORDERS' from prep.ai.mit.edu or one of the sites
  320. listed below.
  321.    If you are on the Internet, you can copy the latest distribution
  322. version of Octave from the file `/pub/octave/octave-M.N.tar.gz', on the
  323. host `ftp.che.utexas.edu'.  This tar file has been compressed with GNU
  324. gzip, so be sure to use binary mode for the transfer.  `M' and `N'
  325. stand for version numbers; look at a listing of the directory through
  326. ftp to see what version is available.  After you unpack the
  327. distribution, be sure to look at the files `README' and `INSTALL'.
  328.    Binaries for several popular systems are also available.  If you
  329. would like help out by making binaries available for other systems,
  330. please contact bug-octave@che.utexas.edu.
  331.    A list of user-visible changes since the last release is available in
  332. the file `NEWS'.  The file `ChangeLog' in the source distribution
  333. contains a more detailed record of changes made since the last release.
  334. File: FAQ.info,  Node: Octave for other platforms,  Next: latest versions,  Prev: Octave for Unix,  Up: Getting Octave
  335. How do I get a copy of Octave for (some other platform)?
  336. ========================================================
  337.    Octave currently runs on Unix-like systems only.  It should be
  338. possible to make Octave work on other systems.  If you are interested
  339. in porting Octave to other systems, please contact
  340. bug-octave@che.utexas.edu.
  341. File: FAQ.info,  Node: latest versions,  Prev: Octave for other platforms,  Up: Getting Octave
  342. What is the latest version of Octave
  343. ====================================
  344.    The latest version of Octave is 1.1.0, released January 1995.
  345. File: FAQ.info,  Node: Installation,  Next: Common problems,  Prev: Getting Octave,  Up: Top
  346. Installation Issues and Problems
  347. ********************************
  348.    Octave requires approximately 50MB of disk storage to unpack and
  349. install (significantly less if you don't compile with debugging
  350. symbols).
  351.    Octave has been compiled and tested with g++ and libg++ on a
  352. SPARCstation 2 running SunOS 4.1.2, an IBM RS/6000 running AIX 3.2.5,
  353. DEC Alpha systems running OSF/1 1.3 and 3.0, a DECstation 5000/240
  354. running Ultrix 4.2a, and i486 systems running Linux.  It should work on
  355. most other Unix systems that have a working port of g++ and libg++.
  356. * Menu:
  357. * What else do I need?::
  358. * Other C++ compilers?::
  359. File: FAQ.info,  Node: What else do I need?,  Next: Other C++ compilers?,  Prev: Installation,  Up: Installation
  360. What else do I need?
  361. ====================
  362.    In order to build Octave, you will need a current version of g++,
  363. libg++, and GNU make.  If you don't have these tools, you can get them
  364. from many anonymous ftp archives, including ftp.che.utexas.edu,
  365. ftp.uu.net, prep.ai.mit.edu, and wuarchive.wustl.edu, or by writing to
  366. the FSF at 675 Mass Ave, Cambridge, MA 02139, USA.
  367. File: FAQ.info,  Node: Other C++ compilers?,  Prev: What else do I need?,  Up: Installation
  368. Can I compile Octave with another C++ compiler?
  369. ===============================================
  370.    Currently, Octave can only be compiled with the GNU C++ compiler.  It
  371. would be nice to make it possible to compile Octave with other C++
  372. compilers, but the maintainers do not have sufficient time to devote to
  373. this.  If you are interested in working to make Octave portable to other
  374. compilers, please contact bug-octave@che.utexas.edu.
  375. File: FAQ.info,  Node: Common problems,  Next: Getting additional help,  Prev: Installation,  Up: Top
  376. Common problems
  377. ***************
  378.    This list is probably far too short.  Feel free to suggest additional
  379. questions (preferably with answers!)
  380.    * Octave takes a long time to find symbols.
  381.      Octave is probably spending this time recursively searching
  382.      directories for function files.  Check the value of your LOADPATH.
  383.      For those elements that end in `//', do any name a very large
  384.      directory tree?  Does it contain directories that have a mixture
  385.      of files and directories?  In order for the recursive directory
  386.      searching code to work efficiently, directories that are to be
  387.      searched recursively should have either function files only, or
  388.      subdirectories only, but not a mixture of both.  Check to make
  389.      sure that Octave's standard set of function files is installed
  390.      this way.
  391. File: FAQ.info,  Node: Getting additional help,  Next: Bug reports,  Prev: Common problems,  Up: Top
  392. Getting additional help
  393. ***********************
  394.    The mailing list
  395.      help-octave@che.utexas.edu
  396. is available for questions related to using, installing, and porting
  397. Octave that are not adequately answered by the Octave manual or by this
  398. document.
  399.    If you would like to join the discussion and receive all messages
  400. sent to the list, please send a short note to
  401.      help-octave-request@che.utexas.edu
  402.                  ^^^^^^^
  403.    *Please do not* send requests to be added or removed from the the
  404. mailing list, or other administrative trivia to the list itself.
  405.    An archive of old postings to the help-octave mailing list is
  406. maintained on ftp.che.utexas.edu in the directory
  407. `/pub/octave/MAILING-LISTS'.
  408. File: FAQ.info,  Node: Bug reports,  Next: MATLAB compatibility,  Prev: Getting additional help,  Up: Top
  409. I think I have found a bug in Octave.
  410. *************************************
  411.    "I think I have found a bug in Octave, but I'm not sure.  How do I
  412. know, and who should I tell?"
  413.    First, see the section on bugs and bug reports in the Octave manual.
  414. The Octave manual is included in the Octave distribution.
  415.    When you report a bug, make sure to describe the type of computer you
  416. are using, the version of the operating system it is running, and the
  417. version of Octave that you are using.  Also provide enough code so that
  418. the Octave maintainers can duplicate your bug.
  419.    If you have Octave working at all, the easiest way to do this is to
  420. use the Octave function `bug_report'.  When you execute this function,
  421. Octave will prompt you for a subject and then invoke the editor on a
  422. file that already contains all the configuration information.  When you
  423. exit the editor, Octave will mail the bug report for you.
  424.    If for some reason you cannot use Octave's `bug_report' function,
  425. mail your bug report to "bug-octave@che.utexas.edu".  Your message
  426. needs to include enough information to allow the maintainers of Octave
  427. to fix the bug.  Please read the section on bugs and bug reports in the
  428. Octave manual for a list of things that should be included in every bug
  429. report.
  430. File: FAQ.info,  Node: MATLAB compatibility,  Next: Index,  Prev: Bug reports,  Up: Top
  431. Porting programs from MATLAB to Octave
  432. **************************************
  433.    "I wrote some code for MATLAB, and I want to get it running under
  434. Octave.  Is there anything I should watch out for?"
  435.    The differences between Octave and MATLAB typically fall into one of
  436. three categories:
  437.   1. Irrelevant.
  438.   2. Known differences, perhaps configurable with a user preference
  439.      variable.
  440.   3. Unknown differences.
  441.    The first category, irrelevant differences, do not affect
  442. computations and most likely do not affect the execution of function
  443. files.  Some examples are:
  444.    When typing `help function', Octave displays the first set of
  445. comment lines *after* the function declaration, but MATLAB the first
  446. set of comment lines starting from the beginning of the file.
  447.    The differences of the second category are usually because the
  448. authors of Octave decided on a better (subjective) implementation that
  449. the way MATLAB does it, and so introduced "user preference variables"
  450. so that you can customize Octave's behavior to be either
  451. MATLAB-compatible or to use Octave's new features.  To make Octave more
  452. MATLAB-compatible, put the following statements in your `~/.octaverc'
  453. file.  This is a partial list of the user preference variables that
  454. should be changed to get MATLAB-compatible behavior.  (It is partial
  455. because not all the differences are currently known, and when they
  456. become known, this document lags behind.)
  457.        do_fortran_indexing = 'true';
  458.        treat_neg_dim_as_zero = 'true';
  459.        empty_list_elements_ok = 'true';
  460.        implicit_str_to_num_ok = 'true';
  461.        whitespace_in_literal_matrix = 'traditional';
  462.        prefer_zero_one_indexing = 'true';
  463.    Some other known differences are:
  464.    * String subscripting is not yet implemented in Octave.  For example,
  465.           a = 'reknob';
  466.           a([6,1,5,3,2,4])
  467.      returns the string `broken' in MATLAB, but generates an error in
  468.      Octave.  A future release of Octave will fix this along with
  469.      providing a much more complete and powerful set of functions for
  470.      manipulating strings.
  471.    * The Octave plotting functions are mostly compatible with the ones
  472.      from MATLAB 3.x, but not from MATLAB 4.x.
  473.    * The C-style I/O functions are not completely compatible.  It would
  474.      be useful for someone to explore the differences so that they
  475.      might be fixed, or at least noted in the manual.
  476.    The third category of differences is (hopefully) shrinking.  If you
  477. find a difference between Octave behavior and MATLAB, then you should
  478. send a description of this difference (with code illustrating the
  479. difference, if possible) to bug-octave@che.utexas.edu.
  480.    An archive of old postings to the Octave mailing lists is maintained
  481. on ftp.che.utexas.edu in the directory `/pub/octave/MAILING-LISTS'.
  482. File: FAQ.info,  Node: Index,  Prev: MATLAB compatibility,  Up: Top
  483. Concept Index
  484. *************
  485. * Menu:
  486. * MATLAB compatibility:                 MATLAB compatibility.
  487. * Additional help:                      Getting additional help.
  488. * Argument lists, variable-length:      Variable-length argument lists.
  489. * Boolean operators, short-circuit:     Short-circuit boolean operators.
  490. * Bug in Octave, newly found:           Bug reports.
  491. * Command completion:                   Command and variable name completion.
  492. * Command history:                      Command history.
  493. * Compatibility with MATLAB:            MATLAB compatibility.
  494. * DASSL:                                Built-in ODE and DAE solvers.
  495. * Data structures:                      Data structures.
  496. * Decrement operators:                  Increment and decrement operators.
  497. * DJGPP:                                Octave for other platforms.
  498. * EMX:                                  Octave for other platforms.
  499. * FAQ for Octave, latest version:       Top.
  500. * Flex:                                 What else do I need?.
  501. * FSF [Free Software Foundation]:       Octave for Unix.
  502. * FSF, contact <gnu@prep.ai.mit.edu>:   Octave for Unix.
  503. * Function name completion:             Command and variable name completion.
  504. * GNU Bison:                            What else do I need?.
  505. * GNU g++:                              What else do I need?.
  506. * GNU gcc:                              What else do I need?.
  507. * GNU Make:                             What else do I need?.
  508. * GNU [GNU's not unix]:                 Octave for Unix.
  509. * GNUware, anonymous FTP sites:         Octave for Unix.
  510. * History:                              Command history.
  511. * Increment operators:                  Increment and decrement operators.
  512. * libg++:                               What else do I need?.
  513. * Logical operators, short-circuit:     Short-circuit boolean operators.
  514. * LSODE:                                Built-in ODE and DAE solvers.
  515. * Mailing lists, bug-octave:            Bug reports.
  516. * Mailing lists, help-octave:           Getting additional help.
  517. * Manual, for Octave:                   Bug reports.
  518. * MS-DOS support:                       Octave for other platforms.
  519. * Name completion:                      Command and variable name completion.
  520. * Octave bug report:                    Bug reports.
  521. * Octave, building:                     Installation.
  522. * Octave, documentation:                Documentation.
  523. * Octave, getting a copy:               Octave for Unix.
  524. * Octave, ordering:                     Octave for Unix.
  525. * Octave, version date:                 latest versions.
  526. * Operators, boolean:                   Short-circuit boolean operators.
  527. * Operators, decrement:                 Increment and decrement operators.
  528. * Operators, increment:                 Increment and decrement operators.
  529. * OS/2 support:                         Octave for other platforms.
  530. * Return lists, variable-length:        Variable-length return lists.
  531. * Short-circuit boolean operators:      Short-circuit boolean operators.
  532. * Source code:                          Getting Octave.
  533. * Structures:                           Data structures.
  534. * Unwind-protect:                       Unwind-protect.
  535. * Variable name completion:             Command and variable name completion.
  536. * Variable-length argument lists:       Variable-length argument lists.
  537. * Variable-length return lists:         Variable-length return lists.
  538. * VAX:                                  Octave for other platforms.
  539. * VMS support:                          Octave for other platforms.
  540. Tag Table:
  541. Node: Top
  542. Node: What is Octave?
  543. Node: Version 1.1.0
  544. Node: Octave Features
  545. Node: Command and variable name completion
  546. Node: Command history
  547. Node: Data structures
  548. Node: Short-circuit boolean operators
  549. Node: Increment and decrement operators
  550. Node: Unwind-protect
  551. Node: Variable-length argument lists
  552. 10555
  553. Node: Variable-length return lists
  554. 11831
  555. Node: Built-in ODE and DAE solvers
  556. 12442
  557. Node: Documentation
  558. 12781
  559. Node: Getting Octave
  560. 13927
  561. Node: Octave for Unix
  562. 14147
  563. Node: Octave for other platforms
  564. 16296
  565. Node: latest versions
  566. 16748
  567. Node: Installation
  568. 16987
  569. Node: What else do I need?
  570. 17695
  571. Node: Other C++ compilers?
  572. 18181
  573. Node: Common problems
  574. 18712
  575. Node: Getting additional help
  576. 19641
  577. Node: Bug reports
  578. 20462
  579. Node: MATLAB compatibility
  580. 21845
  581. Node: Index
  582. 24732
  583. End Tag Table
  584.