home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / octa21eb.zip / octave / doc / oct-faq < prev    next >
Encoding:
GNU Info File  |  1999-05-13  |  28.3 KB  |  779 lines
  1. This is Info file oct-faq, produced by Makeinfo-1.64 from the input
  2. file oct-faq.tex.
  3.  
  4. 
  5. File: oct-faq,  Node: Top,  Next: What is Octave?,  Prev: (dir),  Up: (dir)
  6.  
  7.  
  8.  
  9. Preface
  10. *******
  11.  
  12.    This is a list of frequently asked questions (FAQ) for Octave users.
  13.  
  14.    Some information in this FAQ was written for earlier versions of
  15. Octave and may now be obsolete.
  16.  
  17.    I'm looking for new questions (*with* answers), better answers, or
  18. both.  Please send suggestions to bug-octave@bevo.che.wisc.edu.  If you
  19. have general questions about Octave, or need help for something that is
  20. not covered by the Octave manual or the FAQ, please use the
  21. help-octave@bevo.che.wisc.edu mailing list.
  22.  
  23.    This FAQ is intended to supplement, not replace, the Octave manual.
  24. Before posting a question to the help-octave mailing list, you should
  25. first check to see if the topic is covered in the manual.
  26.  
  27. * Menu:
  28.  
  29. * What is Octave?::
  30. * Version 2.0::
  31. * Octave Features::
  32. * Documentation::
  33. * Getting Octave::
  34. * Installation::
  35. * Common problems::
  36. * Getting additional help::
  37. * Bug reports::
  38. * MATLAB compatibility::
  39. * Index::
  40.  
  41. 
  42. File: oct-faq,  Node: What is Octave?,  Next: Version 2.0,  Prev: Top,  Up: Top
  43.  
  44. What is Octave?
  45. ***************
  46.  
  47.    Octave is a high-level interactive language, primarily intended for
  48. numerical computations that is mostly compatible with MATLAB.(1)
  49.  
  50.    Octave can do arithmetic for real and complex scalars and matrices,
  51. solve sets of nonlinear algebraic equations, integrate functions over
  52. finite and infinite intervals, and integrate systems of ordinary
  53. differential and differential-algebraic equations.
  54.  
  55.    Octave uses the GNU readline library to handle reading and editing
  56. input.  By default, the line editing commands are similar to the cursor
  57. movement commands used by GNU Emacs, and a vi-style line editing
  58. interface is also available.  At the end of each session, the command
  59. history is saved, so that commands entered during previous sessions are
  60. not lost.
  61.  
  62.    The Octave distribution includes a 200+ page Texinfo manual.  Access
  63. to the complete text of the manual is available via the help command at
  64. the Octave prompt.
  65.  
  66.    Two and three dimensional plotting is fully supported using gnuplot.
  67.  
  68.    The underlying numerical solvers are currently standard Fortran ones
  69. like Lapack, Linpack, Odepack, the Blas, etc., packaged in a library of
  70. C++ classes.  If possible, the Fortran subroutines are compiled with
  71. the system's Fortran compiler, and called directly from the C++
  72. functions.  If that's not possible, you can still compile Octave if you
  73. have the free Fortran to C translator f2c.
  74.  
  75.    Octave is also free software; you can redistribute it and/or modify
  76. it under the terms of the GNU General Public License as published by the
  77. Free Software Foundation.
  78.  
  79.    ---------- Footnotes ----------
  80.  
  81.    (1)  MATLAB is a registered trademark of The MathWorks, Inc.
  82.  
  83. 
  84. File: oct-faq,  Node: Version 2.0,  Next: Octave Features,  Prev: What is Octave?,  Up: Top
  85.  
  86. What's new in version 2.0 of Octave
  87. ***********************************
  88.  
  89.    Version 2.0.10 of Octave was released February 6, 1998.  Most bugs
  90. reported since version 2.0 was release have been fixed, and a number of
  91. new features have been added.  Octave is now much more compatible with
  92. MATLAB.
  93.  
  94.    A list of user-visible changes in recent versions of Octave may be
  95. found in the file NEWS, distributed in both source and binary releases
  96. of Octave.
  97.  
  98. 
  99. File: oct-faq,  Node: Octave Features,  Next: Documentation,  Prev: Version 2.0,  Up: Top
  100.  
  101. What features are unique to Octave?
  102. ***********************************
  103.  
  104. * Menu:
  105.  
  106. * Command and variable name completion::
  107. * Command history::
  108. * Data structures::
  109. * Short-circuit boolean operators::
  110. * Increment and decrement operators::
  111. * Unwind-protect::
  112. * Variable-length argument lists::
  113. * Variable-length return lists::
  114. * Built-in ODE and DAE solvers::
  115.  
  116. 
  117. File: oct-faq,  Node: Command and variable name completion,  Next: Command history,  Prev: Octave Features,  Up: Octave Features
  118.  
  119. Command and variable name completion
  120. ====================================
  121.  
  122.    Typing a TAB character (ASCII code 9) on the command line causes
  123. Octave to attempt to complete variable, function, and file names.
  124. Octave uses the text before the cursor as the initial portion of the
  125. name to complete.
  126.  
  127.    For example, if you type `fu' followed by TAB at the Octave prompt,
  128. Octave will complete the rest of the name `function' on the command
  129. line (unless you have other variables or functions defined that begin
  130. with the characters `fu').  If there is more than one possible
  131. completion, Octave will ring the terminal bell to let you know that your
  132. initial sequence of characters is not enough to specify a unique name.
  133. To complete the name, you may either edit the initial character sequence
  134. (usually adding more characters until completion is possible) or type
  135. another TAB to cause Octave to display the list of possible completions.
  136.  
  137. 
  138. File: oct-faq,  Node: Command history,  Next: Data structures,  Prev: Command and variable name completion,  Up: Octave Features
  139.  
  140. Command history
  141. ===============
  142.  
  143.    When running interactively, Octave saves the commands you type in an
  144. internal buffer so that you can recall and edit them.  Emacs and vi
  145. editing modes are available with Emacs keybindings enabled by default.
  146.  
  147.    When Octave exits, the current command history is saved to the file
  148. `~/.octave_hist', and each time Octave starts, it inserts the contents
  149. of the `~/.octave_hist' file in the history list so that it is easy to
  150. begin working where you left off.
  151.  
  152. 
  153. File: oct-faq,  Node: Data structures,  Next: Short-circuit boolean operators,  Prev: Command history,  Up: Octave Features
  154.  
  155. Data structures
  156. ===============
  157.  
  158.    Octave includes a limited amount of support for organizing data in
  159. structures.  The current implementation uses an associative array with
  160. indices limited to strings, but the syntax is more like C-style
  161. structures.  Here are some examples of using data structures in Octave.
  162.  
  163.    * Elements of structures can be of any value type.
  164.  
  165.           octave:1> x.a = 1; x.b = [1, 2; 3, 4]; x.c = "string";
  166.           octave:2> x.a
  167.           x.a = 1
  168.           octave:3> x.b
  169.           x.b =
  170.           
  171.             1  2
  172.             3  4
  173.           
  174.           octave:4> x.c
  175.           x.c = string
  176.  
  177.    * Structures may be copied.
  178.  
  179.           octave:1> y = x
  180.           y =
  181.           {
  182.             a = 1
  183.             b =
  184.           
  185.               1  2
  186.               3  4
  187.           
  188.             c = string
  189.             s =
  190.           
  191.               0.00000  0.00000  0.00000
  192.               0.00000  5.46499  0.00000
  193.               0.00000  0.00000  0.36597
  194.           
  195.             u =
  196.           
  197.               -0.40455  -0.91451
  198.               -0.91451   0.40455
  199.           
  200.             v =
  201.           
  202.               -0.57605   0.81742
  203.               -0.81742  -0.57605
  204.           }
  205.  
  206.    * Structure elements may reference other structures.
  207.  
  208.           octave:1> x.b.d = 3
  209.           x.b.d = 3
  210.           octave:2> x.b
  211.           ans =
  212.           {
  213.             d = 3
  214.           }
  215.           octave:3> x.b.d
  216.           ans = 3
  217.  
  218.    * Functions can return structures.
  219.  
  220.           octave:1> function y = f (x)
  221.           > y.re = real (x);
  222.           > y.im = imag (x);
  223.           > endfunction
  224.           
  225.           octave:2> f (rand + rand*I);
  226.           ans =
  227.           {
  228.             im = 0.18033
  229.             re = 0.19069
  230.           }
  231.  
  232.    * Function return lists can include structure elements, and they may
  233.      be indexed like any other variable.
  234.  
  235.           octave:1> [x.u, x.s(2:3,2:3), x.v] = svd ([1, 2; 3, 4]);
  236.           octave:2> x
  237.           x =
  238.           {
  239.             s =
  240.           
  241.               0.00000  0.00000  0.00000
  242.               0.00000  5.46499  0.00000
  243.               0.00000  0.00000  0.36597
  244.           
  245.             u =
  246.           
  247.               -0.40455  -0.91451
  248.               -0.91451   0.40455
  249.           
  250.             v =
  251.           
  252.               -0.57605   0.81742
  253.               -0.81742  -0.57605
  254.           }
  255.  
  256.    * You can also use the function `is_struct' to determine whether a
  257.      given value is a data structure.  For example
  258.  
  259.           is_struct (x)
  260.  
  261.      returns 1 if the value of the variable X is a data structure.
  262.  
  263.    This feature should be considered experimental, but you should
  264. expect it to work.  Suggestions for ways to improve it are welcome.
  265.  
  266. 
  267. File: oct-faq,  Node: Short-circuit boolean operators,  Next: Increment and decrement operators,  Prev: Data structures,  Up: Octave Features
  268.  
  269. Short-circuit boolean operators
  270. ===============================
  271.  
  272.    Octave's `&&' and `||' logical operators are evaluated in a
  273. short-circuit fashion (like the corresponding operators in the C
  274. language) and work differently than the element by element operators
  275. `&' and `|'.
  276.  
  277. 
  278. File: oct-faq,  Node: Increment and decrement operators,  Next: Unwind-protect,  Prev: Short-circuit boolean operators,  Up: Octave Features
  279.  
  280. Increment and decrement operators
  281. =================================
  282.  
  283.    Octave includes the C-like increment and decrement operators `++'
  284. and `--' in both their prefix and postfix forms.
  285.  
  286.    For example, to pre-increment the variable X, you would write `++X'.
  287. This would add one to X and then return the new value of X as the
  288. result of the expression.  It is exactly the same as the expression `X
  289. = X + 1'.
  290.  
  291.    To post-increment a variable X, you would write `X++'.  This adds
  292. one to the variable X, but returns the value that X had prior to
  293. incrementing it.  For example, if X is equal to 2, the result of the
  294. expression `X++' is 2, and the new value of X is 3.
  295.  
  296.    For matrix and vector arguments, the increment and decrement
  297. operators work on each element of the operand.
  298.  
  299.    It is not currently possible to increment index expressions.  For
  300. example, you might expect that the expression `V(4)++' would increment
  301. the fourth element of the vector V, but instead it results in a parse
  302. error.  This problem may be fixed in a future release of Octave.
  303.  
  304. 
  305. File: oct-faq,  Node: Unwind-protect,  Next: Variable-length argument lists,  Prev: Increment and decrement operators,  Up: Octave Features
  306.  
  307. Unwind-protect
  308. ==============
  309.  
  310.    Octave supports a limited form of exception handling modelled after
  311. the unwind-protect form of Lisp.  The general form of an
  312. `unwind_protect' block looks like this:
  313.  
  314.      unwind_protect
  315.        BODY
  316.      unwind_protect_cleanup
  317.        CLEANUP
  318.      end_unwind_protect
  319.  
  320. Where BODY and CLEANUP are both optional and may contain any Octave
  321. expressions or commands.  The statements in CLEANUP are guaranteed to
  322. be executed regardless of how control exits BODY.
  323.  
  324.    The `unwind_protect' statement is often used to reliably restore the
  325. values of global variables that need to be temporarily changed.
  326.  
  327. 
  328. File: oct-faq,  Node: Variable-length argument lists,  Next: Variable-length return lists,  Prev: Unwind-protect,  Up: Octave Features
  329.  
  330. Variable-length argument lists
  331. ==============================
  332.  
  333.    Octave has a real mechanism for handling functions that take an
  334. unspecified number of arguments, so it is no longer necessary to place
  335. an upper bound on the number of optional arguments that a function can
  336. accept.
  337.  
  338.    Here is an example of a function that uses the new syntax to print a
  339. header followed by an unspecified number of values:
  340.  
  341.      function foo (heading, ...)
  342.        disp (heading);
  343.        va_start ();
  344.        while (--nargin)
  345.          disp (va_arg ());
  346.        endwhile
  347.      endfunction
  348.  
  349.    Calling `va_start()' positions an internal pointer to the first
  350. unnamed argument and allows you to cycle through the arguments more than
  351. once.  It is not necessary to call `va_start()' if you do not plan to
  352. cycle through the arguments more than once.
  353.  
  354.    The function `va_arg()' returns the value of the next available
  355. argument and moves the internal pointer to the next argument.  It is an
  356. error to call `va_arg()' when there are no more arguments available.
  357.  
  358.    It is also possible to use the keyword ALL_VA_ARGS to pass all
  359. unnamed arguments to another function.
  360.  
  361. 
  362. File: oct-faq,  Node: Variable-length return lists,  Next: Built-in ODE and DAE solvers,  Prev: Variable-length argument lists,  Up: Octave Features
  363.  
  364. Variable-length return lists
  365. ============================
  366.  
  367.    Octave also has a real mechanism for handling functions that return
  368. an unspecified number of values, so it is no longer necessary to place
  369. an upper bound on the number of outputs that a function can produce.
  370.  
  371.    Here is an example of a function that uses the new syntax to produce
  372. `N' values:
  373.  
  374.      function [...] = foo (n)
  375.        for i = 1:n
  376.          vr_val (i);
  377.        endfor
  378.      endfunction
  379.  
  380. 
  381. File: oct-faq,  Node: Built-in ODE and DAE solvers,  Prev: Variable-length return lists,  Up: Octave Features
  382.  
  383. Built-in ODE and DAE solvers
  384. ============================
  385.  
  386.    Octave includes LSODE and DASSL for solving systems of stiff ordinary
  387. differential and differential-algebraic equations.  These functions are
  388. built in to the interpreter.
  389.  
  390. 
  391. File: oct-faq,  Node: Documentation,  Next: Getting Octave,  Prev: Octave Features,  Up: Top
  392.  
  393. What documentation exists for Octave?
  394. *************************************
  395.  
  396.    The Octave distribution includes a 220+ page manual that is also
  397. distributed under the terms of the GNU GPL.
  398.  
  399.    The Octave manual is intended to be a complete reference for Octave,
  400. but it is not a finished document.  If you have problems using it, or
  401. find that some topic is not adequately explained, indexed, or
  402. cross-referenced, please send a bug report to
  403. bug-octave@bevo.che.wisc.edu.
  404.  
  405.    Because the Octave manual is written using Texinfo, the complete
  406. text of the Octave manual is also available on line using the GNU Info
  407. system via the GNU Emacs, info, or xinfo programs, or by using the
  408. `help -i' command to start the GNU info browser directly from the
  409. Octave prompt.
  410.  
  411.    It is also possible to use your favorite WWW browser to read the
  412. Octave manual by converting the Texinfo source to HTML using the
  413. `texi2html' program.
  414.  
  415. 
  416. File: oct-faq,  Node: Getting Octave,  Next: Installation,  Prev: Documentation,  Up: Top
  417.  
  418. Obtaining Source Code
  419. *********************
  420.  
  421. * Menu:
  422.  
  423. * Octave for Unix::
  424. * Octave for other platforms::
  425. * latest versions::
  426.  
  427. 
  428. File: oct-faq,  Node: Octave for Unix,  Next: Octave for other platforms,  Prev: Getting Octave,  Up: Getting Octave
  429.  
  430. How do I get a copy of Octave for Unix?
  431. =======================================
  432.  
  433.    You can get Octave from a friend who has a copy, by anonymous FTP,
  434. or by ordering a tape or CD-ROM from the Free Software Foundation (FSF).
  435.  
  436.    Octave was not developed by the FSF, but the FSF does distribute
  437. Octave, and the developers of Octave support the efforts of the FSF by
  438. encouraging users of Octave to order Octave on CD-ROM directly from the
  439. FSF.
  440.  
  441.    The FSF is a nonprofit organization that distributes software and
  442. manuals to raise funds for more GNU development.  Buying a CD-ROM from
  443. the FSF contributes directly to paying staff to develop GNU software.
  444. CD-ROMs cost $240 if an organization is buying, or $60 if an individual
  445. is buying.
  446.  
  447.    For more information about ordering from the FSF, contact
  448. gnu@gnu.org, phone (617) 542-5942 or anonymous ftp the file
  449. `/pub/gnu/GNUinfo/ORDERS' from ftp.gnu.org.
  450.  
  451.    If you are on the Internet, you can copy the latest distribution
  452. version of Octave from the file `/pub/octave/octave-M.N.tar.gz', on the
  453. host `ftp.che.wisc.edu'.  This tar file has been compressed with GNU
  454. gzip, so be sure to use binary mode for the transfer.  `M' and `N'
  455. stand for version numbers; look at a listing of the directory through
  456. ftp to see what version is available.  After you unpack the
  457. distribution, be sure to look at the files `README' and `INSTALL'.
  458.  
  459.    Binaries for several popular systems are also available.  If you
  460. would like help out by making binaries available for other systems,
  461. please contact bug-octave@bevo.che.wisc.edu.
  462.  
  463.    A list of user-visible changes since the last release is available in
  464. the file `NEWS'.  The file `ChangeLog' in the source distribution
  465. contains a more detailed record of changes made since the last release.
  466.  
  467. 
  468. File: oct-faq,  Node: Octave for other platforms,  Next: latest versions,  Prev: Octave for Unix,  Up: Getting Octave
  469.  
  470. How do I get a copy of Octave for (some other platform)?
  471. ========================================================
  472.  
  473.    Octave currently runs on Unix-like systems, OS/2, and Windows NT/95
  474. (using the gnu-win32 tools from Cygnus Support).  It should be possible
  475. to make Octave work on other systems as well.  If you are interested in
  476. porting Octave to other systems, please contact
  477. bug-octave@bevo.che.wisc.edu.
  478.  
  479. 
  480. File: oct-faq,  Node: latest versions,  Prev: Octave for other platforms,  Up: Getting Octave
  481.  
  482. What is the latest version of Octave
  483. ====================================
  484.  
  485.    The latest version of Octave is 2.0.10, released February 6, 1998.
  486.  
  487. 
  488. File: oct-faq,  Node: Installation,  Next: Common problems,  Prev: Getting Octave,  Up: Top
  489.  
  490. Installation Issues and Problems
  491. ********************************
  492.  
  493.    Octave requires approximately 125MB of disk storage to unpack and
  494. compile from source (significantly less if you don't compile with
  495. debugging symbols or create shared libraries).  Once installed, Octave
  496. requires approximately 65MB of disk space (again, considerably less if
  497. you don't build shared libraries or the binaries and libraries do not
  498. include debugging symbols).
  499.  
  500. * Menu:
  501.  
  502. * What else do I need?::
  503. * Other C++ compilers?::
  504.  
  505. 
  506. File: oct-faq,  Node: What else do I need?,  Next: Other C++ compilers?,  Prev: Installation,  Up: Installation
  507.  
  508. What else do I need?
  509. ====================
  510.  
  511.    To compile Octave, you will need a recent version of GNU Make.  You
  512. will also need g++ 2.7.2 or later.  Version 2.8.0 or egcs 1.0.x should
  513. work.  Later versions may work, but C++ is still evolving, so don't be
  514. too surprised if you run into some trouble.
  515.  
  516.    It is no longer necessary to have libg++, but you do need to have the
  517. GNU implementation of libstdc++.  If you are using g++ 2.7.2, libstdc++
  518. is distributed along with libg++, but for later versions, libstdc++ is
  519. distributed separately.  For egcs, libstdc++ is included with the
  520. compiler distribution.
  521.  
  522.    <em>You must have gnu make to compile octave</em>.  Octave's
  523. Makefiles use features of GNU Make that are not present in other
  524. versions of make.  GNU Make is very portable and easy to install.
  525.  
  526. 
  527. File: oct-faq,  Node: Other C++ compilers?,  Prev: What else do I need?,  Up: Installation
  528.  
  529. Can I compile Octave with another C++ compiler?
  530. ===============================================
  531.  
  532.    Currently, Octave can only be compiled with the GNU C++ compiler.  It
  533. would be nice to make it possible to compile Octave with other C++
  534. compilers, but the maintainers do not have sufficient time to devote to
  535. this.  If you are interested in working to make Octave portable to other
  536. compilers, please contact bug-octave@bevo.che.wisc.edu.
  537.  
  538. 
  539. File: oct-faq,  Node: Common problems,  Next: Getting additional help,  Prev: Installation,  Up: Top
  540.  
  541. Common problems
  542. ***************
  543.  
  544.    This list is probably far too short.  Feel free to suggest additional
  545. questions (preferably with answers!)
  546.  
  547.    * Octave takes a long time to find symbols.
  548.  
  549.      Octave is probably spending this time recursively searching
  550.      directories for function files.  Check the value of your LOADPATH.
  551.      For those elements that end in `//', do any name a very large
  552.      directory tree?  Does it contain directories that have a mixture
  553.      of files and directories?  In order for the recursive directory
  554.      searching code to work efficiently, directories that are to be
  555.      searched recursively should have either function files only, or
  556.      subdirectories only, but not a mixture of both.  Check to make
  557.      sure that Octave's standard set of function files is installed
  558.      this way.
  559.  
  560. 
  561. File: oct-faq,  Node: Getting additional help,  Next: Bug reports,  Prev: Common problems,  Up: Top
  562.  
  563. Getting additional help
  564. ***********************
  565.  
  566.    The mailing list
  567.  
  568.      help-octave@bevo.che.wisc.edu
  569.  
  570. is available for questions related to using, installing, and porting
  571. Octave that are not adequately answered by the Octave manual or by this
  572. document.
  573.  
  574.    If you would like to join the discussion and receive all messages
  575. sent to the list, please send a short note to
  576.  
  577.      help-octave-request@bevo.che.wisc.edu
  578.                  ^^^^^^^
  579.  
  580.    *Please do not* send requests to be added or removed from the the
  581. mailing list, or other administrative trivia to the list itself.
  582.  
  583.    An archive of old postings to the help-octave mailing list is
  584. maintained on ftp.che.wisc.edu in the directory
  585. `/pub/octave/MAILING-LISTS'.
  586.  
  587. 
  588. File: oct-faq,  Node: Bug reports,  Next: MATLAB compatibility,  Prev: Getting additional help,  Up: Top
  589.  
  590. I think I have found a bug in Octave.
  591. *************************************
  592.  
  593.    "I think I have found a bug in Octave, but I'm not sure.  How do I
  594. know, and who should I tell?"
  595.  
  596.    First, see the section on bugs and bug reports in the Octave manual.
  597. The Octave manual is included in the Octave distribution.
  598.  
  599.    When you report a bug, make sure to describe the type of computer you
  600. are using, the version of the operating system it is running, and the
  601. version of Octave that you are using.  Also provide enough code so that
  602. the Octave maintainers can duplicate your bug.
  603.  
  604.    If you have Octave working at all, the easiest way to do this is to
  605. use the Octave function `bug_report'.  When you execute this function,
  606. Octave will prompt you for a subject and then invoke the editor on a
  607. file that already contains all the configuration information.  When you
  608. exit the editor, Octave will mail the bug report for you.
  609.  
  610.    If for some reason you cannot use Octave's `bug_report' function,
  611. mail your bug report to "bug-octave@bevo.che.wisc.edu".  Your message
  612. needs to include enough information to allow the maintainers of Octave
  613. to fix the bug.  Please read the section on bugs and bug reports in the
  614. Octave manual for a list of things that should be included in every bug
  615. report.
  616.  
  617. 
  618. File: oct-faq,  Node: MATLAB compatibility,  Next: Index,  Prev: Bug reports,  Up: Top
  619.  
  620. Porting programs from MATLAB to Octave
  621. **************************************
  622.  
  623.    "I wrote some code for MATLAB, and I want to get it running under
  624. Octave.  Is there anything I should watch out for?"
  625.  
  626.    The differences between Octave and MATLAB typically fall into one of
  627. three categories:
  628.  
  629.   1. Irrelevant.
  630.  
  631.   2. Known differences, perhaps configurable with a user preference
  632.      variable.
  633.  
  634.   3. Unknown differences.
  635.  
  636.    The first category, irrelevant differences, do not affect
  637. computations and most likely do not affect the execution of function
  638. files.
  639.  
  640.    The differences of the second category are usually because the
  641. authors of Octave decided on a better (subjective) implementation that
  642. the way MATLAB does it, and so introduced "user preference variables"
  643. so that you can customize Octave's behavior to be either
  644. MATLAB-compatible or to use Octave's new features.  To make Octave more
  645. MATLAB-compatible, put the following statements in your `~/.octaverc'
  646. file, or use the command line option `--traditional', which implies all
  647. of these settings.  Note that this list may not be complete, because
  648. some new variables may have been introduced since this document was
  649. last updated.
  650.  
  651.        PS1 = ">> "
  652.        PS2 = ""
  653.        beep_on_error = 1.0
  654.        default_eval_print_flag = 0.0
  655.        default_save_format = "mat-binary"
  656.        define_all_return_values = 1.0
  657.        do_fortran_indexing = 1.0
  658.        empty_list_elements_ok = 1.0
  659.        fixed_point_format = 1.0
  660.        implicit_num_to_str_ok = 1.0
  661.        implicit_str_to_num_ok = 1.0
  662.        ok_to_lose_imaginary_part = 1.0
  663.        page_screen_output = 0.0
  664.        prefer_column_vectors = 0.0
  665.        prefer_zero_one_indexing = 1.0
  666.        print_empty_dimensions = 0.0
  667.        treat_neg_dim_as_zero = 1.0
  668.        warn_function_name_clash = 0.0
  669.        whitespace_in_literal_matrix = "traditional"
  670.  
  671.    Some other known differences are:
  672.  
  673.    * The Octave plotting functions are mostly compatible with the ones
  674.      from MATLAB 3.x, but not from MATLAB 4.x.
  675.  
  676.    The third category of differences is (hopefully) shrinking.  If you
  677. find a difference between Octave behavior and MATLAB, then you should
  678. send a description of this difference (with code illustrating the
  679. difference, if possible) to bug-octave@bevo.che.wisc.edu.
  680.  
  681.    An archive of old postings to the Octave mailing lists is maintained
  682. on ftp.che.wisc.edu in the directory `/pub/octave/MAILING-LISTS'.
  683.  
  684. 
  685. File: oct-faq,  Node: Index,  Prev: MATLAB compatibility,  Up: Top
  686.  
  687. Concept Index
  688. *************
  689.  
  690. * Menu:
  691.  
  692. * MATLAB compatibility:                 MATLAB compatibility.
  693. * Additional help:                      Getting additional help.
  694. * Argument lists, variable-length:      Variable-length argument lists.
  695. * Boolean operators, short-circuit:     Short-circuit boolean operators.
  696. * Bug in Octave, newly found:           Bug reports.
  697. * Command completion:                   Command and variable name completion.
  698. * Command history:                      Command history.
  699. * Compatibility with MATLAB:            MATLAB compatibility.
  700. * DASSL:                                Built-in ODE and DAE solvers.
  701. * Data structures:                      Data structures.
  702. * Decrement operators:                  Increment and decrement operators.
  703. * DJGPP:                                Octave for other platforms.
  704. * EMX:                                  Octave for other platforms.
  705. * FAQ for Octave, latest version:       Top.
  706. * Flex:                                 What else do I need?.
  707. * FSF [Free Software Foundation]:       Octave for Unix.
  708. * FSF, contact <gnu@prep.ai.mit.edu>:   Octave for Unix.
  709. * Function name completion:             Command and variable name completion.
  710. * GNU Bison:                            What else do I need?.
  711. * GNU g++:                              What else do I need?.
  712. * GNU gcc:                              What else do I need?.
  713. * GNU Make:                             What else do I need?.
  714. * GNU [GNU's not unix]:                 Octave for Unix.
  715. * GNUware, anonymous FTP sites:         Octave for Unix.
  716. * History:                              Command history.
  717. * Increment operators:                  Increment and decrement operators.
  718. * libg++:                               What else do I need?.
  719. * Logical operators, short-circuit:     Short-circuit boolean operators.
  720. * LSODE:                                Built-in ODE and DAE solvers.
  721. * Mailing lists, bug-octave:            Bug reports.
  722. * Mailing lists, help-octave:           Getting additional help.
  723. * Manual, for Octave:                   Bug reports.
  724. * MS-DOS support:                       Octave for other platforms.
  725. * Name completion:                      Command and variable name completion.
  726. * Octave bug report:                    Bug reports.
  727. * Octave, building:                     Installation.
  728. * Octave, documentation:                Documentation.
  729. * Octave, getting a copy:               Octave for Unix.
  730. * Octave, ordering:                     Octave for Unix.
  731. * Octave, version date:                 latest versions.
  732. * Operators, boolean:                   Short-circuit boolean operators.
  733. * Operators, decrement:                 Increment and decrement operators.
  734. * Operators, increment:                 Increment and decrement operators.
  735. * OS/2 support:                         Octave for other platforms.
  736. * Return lists, variable-length:        Variable-length return lists.
  737. * Short-circuit boolean operators:      Short-circuit boolean operators.
  738. * Source code:                          Getting Octave.
  739. * Structures:                           Data structures.
  740. * Unwind-protect:                       Unwind-protect.
  741. * Variable name completion:             Command and variable name completion.
  742. * Variable-length argument lists:       Variable-length argument lists.
  743. * Variable-length return lists:         Variable-length return lists.
  744. * VAX:                                  Octave for other platforms.
  745. * VMS support:                          Octave for other platforms.
  746. * Windows support:                      Octave for other platforms.
  747.  
  748.  
  749. 
  750. Tag Table:
  751. Node: Top87
  752. Node: What is Octave?1097
  753. Node: Version 2.02870
  754. Node: Octave Features3413
  755. Node: Command and variable name completion3864
  756. Node: Command history4926
  757. Node: Data structures5551
  758. Node: Short-circuit boolean operators8346
  759. Node: Increment and decrement operators8767
  760. Node: Unwind-protect9963
  761. Node: Variable-length argument lists10732
  762. Node: Variable-length return lists12007
  763. Node: Built-in ODE and DAE solvers12617
  764. Node: Documentation12964
  765. Node: Getting Octave13974
  766. Node: Octave for Unix14193
  767. Node: Octave for other platforms16083
  768. Node: latest versions16613
  769. Node: Installation16856
  770. Node: What else do I need?17454
  771. Node: Other C++ compilers?18372
  772. Node: Common problems18905
  773. Node: Getting additional help19833
  774. Node: Bug reports20657
  775. Node: MATLAB compatibility22042
  776. Node: Index24541
  777. 
  778. End Tag Table
  779.