Mercurial > hg > octave-lyh

comparison doc/interpreter/octave.texi @ 9032:349616d9c38e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Cleanup top-level documentation menu in octave.texi @detailmenu is now completely up to date with respect to included .texi files @sp construct replaced with an equivalent because it produces ugly HTML output Spellchecked file
author Rik <rdrider0-list@yahoo.com>
date Fri, 20 Mar 2009 10:08:57 -0700
parents eb63fbe60fab
children 57649dcecb55
comparison
equal deleted inserted replaced
9031:1052a66078cf 9032:349616d9c38e
28 @macro seealso {args} 28 @macro seealso {args}
29 @iftex 29 @iftex
30 @vskip 2pt 30 @vskip 2pt
31 @end iftex 31 @end iftex
32 @ifnottex 32 @ifnottex
33 @sp 1 33 @c Texinfo @sp should work but in practice produces ugly results for HTML.
34 @c A simple blank line produces the correct behavior.
35 @c @sp 1
36
34 @end ifnottex 37 @end ifnottex
35 @noindent 38 @noindent
36 @strong{See also:} \args\. 39 @strong{See also:} \args\.
37 @end macro 40 @end macro
38 41
151 * Data Types:: 154 * Data Types::
152 * Numeric Data Types:: 155 * Numeric Data Types::
153 * Strings:: 156 * Strings::
154 * Data Containers:: 157 * Data Containers::
155 * Variables:: 158 * Variables::
156 * Expressions:: Expressions. 159 * Expressions::
157 * Evaluation:: 160 * Evaluation::
158 * Statements:: Looping and program flow control. 161 * Statements:: Looping and program flow control.
159 * Functions and Scripts:: 162 * Functions and Scripts::
160 * Errors and Warnings:: 163 * Errors and Warnings::
161 * Debugging:: 164 * Debugging::
181 * Object Oriented Programming:: 184 * Object Oriented Programming::
182 * System Utilities:: 185 * System Utilities::
183 * Packages:: 186 * Packages::
184 * Dynamically Linked Functions:: 187 * Dynamically Linked Functions::
185 * Test and Demo Functions:: 188 * Test and Demo Functions::
186 * Tips:: 189 * Tips and Standards::
187 * Contributing Guidelines:: 190 * Contributing Guidelines::
188 * Trouble:: If you have trouble installing Octave. 191 * Trouble:: If you have trouble installing Octave.
189 * Installation:: How to configure, compile and install Octave. 192 * Installation:: How to configure, compile and install Octave.
190 * Emacs:: 193 * Emacs Octave Support::
191 @c * Grammar:: 194 @c * Grammar::
192 * Copying:: The GNU General Public License. 195 * Copying:: The GNU General Public License.
193 * Concept Index:: An item for each concept. 196 * Concept Index:: An item for each concept.
194 * Function Index:: An item for each documented function. 197 * Function Index:: An item for each documented function.
195 * Operator Index:: An item for each documented operator. 198 * Operator Index:: An item for each documented operator.
196 199
197 @c FIXME -- is the detailed node listing up to date?
198 @detailmenu 200 @detailmenu
199 --- The Detailed Node Listing --- 201 --- The Detailed Node Listing ---
200 202
201 Preface 203 Preface
202 204
203 * Acknowledgements:: 205 * Acknowledgements::
204 * How You Can Contribute to Octave:: 206 * How You Can Contribute to Octave::
205 * Distribution:: 207 * Distribution::
206 208
207 A Brief Introduction to Octave 209 Introduction
208 210
209 * Running Octave:: 211 * Running Octave::
210 * Simple Examples:: 212 * Simple Examples::
211 * Conventions:: 213 * Conventions::
212 214
257 * Object Sizes:: 259 * Object Sizes::
258 260
259 Built-in Data Types 261 Built-in Data Types
260 262
261 * Numeric Objects:: 263 * Numeric Objects::
264 * Missing Data::
262 * String Objects:: 265 * String Objects::
263 * Data Structure Objects:: 266 * Data Structure Objects::
267 * Cell Array Objects::
264 268
265 Numeric Data Types 269 Numeric Data Types
266 270
267 * Matrices:: 271 * Matrices::
268 * Ranges:: 272 * Ranges::
275 279
276 Matrices 280 Matrices
277 281
278 * Empty Matrices:: 282 * Empty Matrices::
279 283
284 Integer Data Types
285
286 * Integer Arithmetic::
287
280 Strings 288 Strings
281 289
282 * Creating Strings:: 290 * Escape Sequences in string constants::
283 * Comparing Strings:: 291 * Character Arrays::
292 * Creating Strings::
293 * Comparing Strings::
284 * Manipulating Strings:: 294 * Manipulating Strings::
285 * String Conversions:: 295 * String Conversions::
286 * Character Class Functions:: 296 * Character Class Functions::
287 297
298 Creating Strings
299
300 * Concatenating Strings::
301 * Conversion of Numerical Data to Strings::
302
288 Data Containers 303 Data Containers
289 304
290 * Data Structures:: 305 * Data Structures::
291 * Cell Arrays:: 306 * Cell Arrays::
292 * Comma Separated Lists:: 307 * Comma Separated Lists::
308
309 Data Structures
310
311 * Structure Arrays::
312 * Creating Structures::
313 * Manipulating Structures::
314 * Processing Data in Structures::
315
316 Cell Arrays
317
318 * Creating Cell Arrays::
319 * Indexing Cell Arrays::
320 * Cell Arrays of Strings::
321 * Processing Data in Cell Arrays::
322
323 Variables
324
325 * Global Variables::
326 * Persistent Variables::
327 * Status of Variables::
293 328
294 Expressions 329 Expressions
295 330
296 * Index Expressions:: 331 * Index Expressions::
297 * Calling Functions:: 332 * Calling Functions::
302 * Increment Ops:: 337 * Increment Ops::
303 * Operator Precedence:: 338 * Operator Precedence::
304 339
305 Calling Functions 340 Calling Functions
306 341
307 Variables
308
309 * Global Variables::
310 * Status of Variables::
311
312 * Call by Value:: 342 * Call by Value::
313 * Recursion:: 343 * Recursion::
314 344
315 Boolean Expressions 345 Boolean Expressions
316 346
317 * Element-by-element Boolean Operators:: 347 * Element-by-element Boolean Operators::
318 * Short-circuit Boolean Operators:: 348 * Short-circuit Boolean Operators::
349
350 Evaluation
351
352 * Calling a Function by its Name::
353 * Evaluation in a Different Context::
319 354
320 Statements 355 Statements
321 356
322 * The if Statement:: 357 * The if Statement::
323 * The switch Statement:: 358 * The switch Statement::
328 * The continue Statement:: 363 * The continue Statement::
329 * The unwind_protect Statement:: 364 * The unwind_protect Statement::
330 * The try Statement:: 365 * The try Statement::
331 * Continuation Lines:: 366 * Continuation Lines::
332 367
368 The @code{switch} Statement
369
370 * Notes for the C programmer::
371
333 The @code{for} Statement 372 The @code{for} Statement
334 373
335 * Looping Over Structure Elements:: 374 * Looping Over Structure Elements::
336 375
337 Functions and Script Files 376 Functions and Scripts
338 377
339 * Defining Functions:: 378 * Defining Functions::
340 * Multiple Return Values:: 379 * Multiple Return Values::
341 * Variable-length Argument Lists:: 380 * Variable-length Argument Lists::
342 * Variable-length Return Lists:: 381 * Variable-length Return Lists::
343 * Returning From a Function:: 382 * Returning From a Function::
383 * Default Arguments::
344 * Function Files:: 384 * Function Files::
345 * Script Files:: 385 * Script Files::
386 * Function Handles Inline Functions and Anonymous Functions::
387 * Commands::
346 * Organization of Functions:: 388 * Organization of Functions::
389
390 Function Files
391
392 * Manipulating the load path::
393 * Subfunctions::
394 * Private Functions::
395 * Overloading and Autoloading::
396 * Function Locking::
397 * Function Precedence::
398
399 Function Handles Inline Functions and Anonymous Functions
400
401 * Function Handles::
402 * Anonymous Functions::
403 * Inline Functions::
347 404
348 Errors and Warnings 405 Errors and Warnings
349 406
350 * Handling Errors:: 407 * Handling Errors::
351 * Handling Warnings:: 408 * Handling Warnings::
409
410 Handling Errors
411
412 * Raising Errors::
413 * Catching Errors::
414
415 Handling Warnings
416
417 * Issuing Warnings::
418 * Enabling and Disabling Warnings::
352 419
353 Debugging 420 Debugging
354 421
355 * Entering Debug Mode:: 422 * Entering Debug Mode::
356 * Leaving Debug Mode:: 423 * Leaving Debug Mode::
366 Basic Input and Output 433 Basic Input and Output
367 434
368 * Terminal Output:: 435 * Terminal Output::
369 * Terminal Input:: 436 * Terminal Input::
370 * Simple File I/O:: 437 * Simple File I/O::
438 * Rational Approximations::
439
440 Terminal Output
441
442 * Paging Screen Output::
443
444 Simple File I/O
445
446 * Saving Data on Unexpected Exits::
371 447
372 C-Style I/O Functions 448 C-Style I/O Functions
373 449
374 * Opening and Closing Files:: 450 * Opening and Closing Files::
375 * Simple Output:: 451 * Simple Output::
394 Plotting 470 Plotting
395 471
396 * Plotting Basics:: 472 * Plotting Basics::
397 * Advanced Plotting:: 473 * Advanced Plotting::
398 474
475 Plotting Basics
476
477 * Two-Dimensional Plots::
478 * Three-Dimensional Plotting::
479 * Plot Annotations::
480 * Multiple Plots on One Page::
481 * Multiple Plot Windows::
482 * Printing Plots::
483 * Interacting with plots::
484 * Test Plotting Functions::
485
486 Two-Dimensional Plots
487
488 * Two-dimensional Function Plotting::
489
490 Three-Dimensional Plotting
491
492 * Three-dimensional Function Plotting::
493 * Three-dimensional Geometric Shapes::
494
495 Advanced Plotting
496
497 * Graphics Objects::
498 * Graphics Object Properties::
499 * Managing Default Properties::
500 * Colors::
501 * Line Styles::
502 * Marker Styles::
503 * Callbacks::
504 * Object Groups::
505 * Graphics backends::
506
507 Graphics Object Properties
508
509 * Root Figure Properties::
510 * Figure Properties::
511 * Axes Properties::
512 * Line Properties::
513 * Text Properties::
514 * Image Properties::
515 * Patch Properties::
516 * Surface Properties::
517 * Searching Properties::
518
519 Object Groups
520
521 * Data sources in object groups::
522 * Area series::
523 * Bar series::
524 * Contour groups::
525 * Error bar series::
526 * Line series::
527 * Quiver group::
528 * Scatter group::
529 * Stair group::
530 * Stem Series::
531 * Surface group::
532
533 Graphics backends
534
535 * Interaction with gnuplot::
536
399 Matrix Manipulation 537 Matrix Manipulation
400 538
401 * Finding Elements and Checking Conditions:: 539 * Finding Elements and Checking Conditions::
402 * Rearranging Matrices:: 540 * Rearranging Matrices::
403 * Applying a Function to an Array:: 541 * Applying a Function to an Array::
409 * Utility Functions:: 547 * Utility Functions::
410 * Complex Arithmetic:: 548 * Complex Arithmetic::
411 * Trigonometry:: 549 * Trigonometry::
412 * Sums and Products:: 550 * Sums and Products::
413 * Special Functions:: 551 * Special Functions::
552 * Coordinate Transformations::
414 * Mathematical Constants:: 553 * Mathematical Constants::
415 554
416 Linear Algebra 555 Linear Algebra
417 556
418 * Techniques used for Linear Algebra:: 557 * Techniques used for Linear Algebra::
419 * Basic Matrix Functions:: 558 * Basic Matrix Functions::
420 * Matrix Factorizations:: 559 * Matrix Factorizations::
421 * Functions of a Matrix:: 560 * Functions of a Matrix::
561 * Specialized Solvers::
422 562
423 Diagonal and Permutation Matrices 563 Diagonal and Permutation Matrices
424 564
425 * Basic Usage:: 565 * Basic Usage:: Creation and Manipulation of Diagonal and Permutation Matrices
426 * Matrix Algebra:: 566 * Matrix Algebra:: Linear Algebra with Diagonal and Permutation Matrices
427 * Function Support:: 567 * Function Support:: Functions That Are Aware of These Matrices
428 * Example Codes:: 568 * Example Codes:: Some Examples of Usage
429 * Zeros Treatment:: 569 * Zeros Treatment:: The Differences in Treatment of Zero Elements
570
571 Basic Usage
572
573 * Creating Diagonal Matrices::
574 * Creating Permutation Matrices::
575 * Explicit and Implicit Conversions::
576
577 Matrix Algebra
578
579 * Expressions Involving Diagonal Matrices::
580 * Expressions Involving Permutation Matrices::
581
582 Function Support
583
584 * Diagonal Matrix Functions::
585 * Permutation Matrix Functions::
430 586
431 Sparse Matrices 587 Sparse Matrices
432 588
433 * Basics:: 589 * Basics:: Creation and Manipulation of Sparse Matrices
434 * Sparse Linear Algebra:: 590 * Sparse Linear Algebra:: Linear Algebra on Sparse Matrices
435 * Iterative Techniques:: 591 * Iterative Techniques:: Iterative Techniques
436 * Real Life Example:: 592 * Real Life Example:: Using Sparse Matrices
593
594 Basics
595
596 * Storage of Sparse Matrices::
597 * Creating Sparse Matrices::
598 * Information::
599 * Operators and Functions::
600
601 Operators and Functions
602
603 * Sparse Functions::
604 * Return Types of Operators and Functions::
605 * Mathematical Considerations::
437 606
438 Numerical Integration 607 Numerical Integration
439 608
440 * Functions of One Variable:: 609 * Functions of One Variable::
610 * Functions of Multiple Variables::
441 * Orthogonal Collocation:: 611 * Orthogonal Collocation::
442 * Functions of Multiple Variables::
443 612
444 Differential Equations 613 Differential Equations
445 614
446 * Ordinary Differential Equations:: 615 * Ordinary Differential Equations::
447 * Differential-Algebraic Equations:: 616 * Differential-Algebraic Equations::
448 617
449 Optimization 618 Optimization
450 619
620 * Linear Programming::
451 * Quadratic Programming:: 621 * Quadratic Programming::
452 * Nonlinear Programming:: 622 * Nonlinear Programming::
453 * Linear Least Squares:: 623 * Linear Least Squares::
454 624
455 Statistics 625 Statistics
485 * Delaunay Triangulation:: 655 * Delaunay Triangulation::
486 * Voronoi Diagrams:: 656 * Voronoi Diagrams::
487 * Convex Hull:: 657 * Convex Hull::
488 * Interpolation on Scattered Data:: 658 * Interpolation on Scattered Data::
489 659
660 Delaunay Triangulation
661
662 * Plotting the Triangulation::
663 * Identifying points in Triangulation::
664
490 Image Processing 665 Image Processing
491 666
492 * Loading and Saving Images:: 667 * Loading and Saving Images::
493 * Displaying Images:: 668 * Displaying Images::
494 * Representing Images:: 669 * Representing Images::
495 * Plotting on top of Images:: 670 * Plotting on top of Images::
496 * Color Conversion:: 671 * Color Conversion::
497 672
498 Object Oriented Programming 673 Object Oriented Programming
499 674
500 * Creating a Class: 675 * Creating a Class::
501 * Manipulating Classes:: 676 * Manipulating Classes::
502 * Indexing Objects:: 677 * Indexing Objects::
503 * Overloading Objects:: 678 * Overloading Objects::
679
680 Overloading Objects
681
682 * Function Overloading::
683 * Operator Overloading::
684 * Precedence of Objects::
504 685
505 System Utilities 686 System Utilities
506 687
507 * Timing Utilities:: 688 * Timing Utilities::
508 * Filesystem Utilities:: 689 * Filesystem Utilities::
517 * System Information:: 698 * System Information::
518 * Hashing Functions:: 699 * Hashing Functions::
519 700
520 Packages 701 Packages
521 702
522 * Installing and Removing Packages:: 703 * Installing and Removing Packages::
523 * Using Packages:: 704 * Using Packages::
524 * Administrating Packages:: 705 * Administrating Packages::
525 * Creating Packages:: 706 * Creating Packages::
707
708 Creating Packages
709
526 * The DESCRIPTION File:: 710 * The DESCRIPTION File::
527 * The INDEX file:: 711 * The INDEX file::
528 * PKG_ADD and PKG_DEL directives:: 712 * PKG_ADD and PKG_DEL directives::
529 713
530 Dynamically Linked Functions 714 Dynamically Linked Functions
531 715
532 * Oct-Files:: 716 * Oct-Files::
533 * Mex-Files:: 717 * Mex-Files::
534 * Standalone Programs:: 718 * Standalone Programs::
719
720 Oct-Files
721
722 * Getting Started with Oct-Files::
723 * Matrices and Arrays in Oct-Files::
724 * Character Strings in Oct-Files::
725 * Cell Arrays in Oct-Files::
726 * Structures in Oct-Files::
727 * Sparse Matrices in Oct-Files::
728 * Accessing Global Variables in Oct-Files::
729 * Calling Octave Functions from Oct-Files::
730 * Calling External Code from Oct-Files::
731 * Allocating Local Memory in Oct-Files::
732 * Input Parameter Checking in Oct-Files::
733 * Exception and Error Handling in Oct-Files::
734 * Documentation and Test of Oct-Files::
735
736 Sparse Matrices in Oct-Files
737
738 * Array and Sparse Differences::
739 * Creating Sparse Matrices in Oct-Files::
740 * Using Sparse Matrices in Oct-Files::
741
742 Mex-Files
743
744 * Getting Started with Mex-Files::
745 * Working with Matrices and Arrays in Mex-Files::
746 * Character Strings in Mex-Files::
747 * Cell Arrays with Mex-Files::
748 * Structures with Mex-Files::
749 * Sparse Matrices with Mex-Files::
750 * Calling Other Functions in Mex-Files::
535 751
536 Test and Demo Functions 752 Test and Demo Functions
537 753
538 * Test Functions:: 754 * Test Functions::
539 * Demonstration Functions:: 755 * Demonstration Functions::
540 756
541 Tips and Standards 757 Tips and Standards
542 758
543 * Style Tips:: Writing clean and robust programs. 759 * Style Tips:: Writing clean and robust programs.
544 * Coding Tips:: Making code run faster. 760 * Coding Tips:: Making code run faster.
545 * Documentation Tips:: Writing readable documentation strings.
546 * Comment Tips:: Conventions for writing comments. 761 * Comment Tips:: Conventions for writing comments.
547 * Function Headers:: Standard headers for functions. 762 * Function Headers:: Standard headers for functions.
548 763 * Documentation Tips:: Writing readable documentation strings.
549 Known Causes of Trouble with Octave 764
765 Contributing Guidelines
766
767 * How to Contribute::
768 * General Guidelines::
769 * Octave Sources (m-files)::
770 * C++ Sources::
771 * Other Sources::
772
773 Trouble
550 774
551 * Actual Bugs:: Bugs we will fix later. 775 * Actual Bugs:: Bugs we will fix later.
552 * Reporting Bugs:: 776 * Reporting Bugs::
553 * Bug Criteria:: 777 * Bug Criteria::
554 * Bug Lists:: 778 * Bug Lists::
561 * Bug Criteria:: 785 * Bug Criteria::
562 * Where: Bug Lists. Where to send your bug report. 786 * Where: Bug Lists. Where to send your bug report.
563 * Reporting: Bug Reporting. How to report a bug effectively. 787 * Reporting: Bug Reporting. How to report a bug effectively.
564 * Patches: Sending Patches. How to send a patch for Octave. 788 * Patches: Sending Patches. How to send a patch for Octave.
565 789
566 Installing Octave 790 Installation
567 791
568 * Installation Problems:: 792 * Installation Problems::
569 793
570 Emacs Octave Support 794 Emacs Octave Support
571 795
572 * Installing EOS:: 796 * Installing EOS::
573 * Using Octave Mode:: 797 * Using Octave Mode::
574 * Running Octave From Within Emacs:: 798 * Running Octave From Within Emacs::
575 * Using the Emacs Info Reader for Octave:: 799 * Using the Emacs Info Reader for Octave::
576
577 @c Grammar
578 @c
579 @c * Keywords::
580
581 @end detailmenu 800 @end detailmenu
582 @end menu 801 @end menu
583 802
584 @c ------------------------------------------------------------------------ 803 @c ------------------------------------------------------------------------
585 804
623 @c maybe add again later, if anyone every writes any really interesting 842 @c maybe add again later, if anyone every writes any really interesting
624 @c fun stuff for Octave. 843 @c fun stuff for Octave.
625 @c 844 @c
626 @c @include amuse.texi 845 @c @include amuse.texi
627 846
628 @c Appendices start here. Installation and bugs have to go before the 847 @c ------------------------------------------------------------------------
629 @c readline and Info appendices because we want to have separate indices 848 @c Appendices start here.
630 @c for them, and there appears to be no way to go back to the original
631 @c set of indices once a redirection has taken place.
632 849
633 @include dynamic.texi 850 @include dynamic.texi
634 @include testfun.texi 851 @include testfun.texi
635 @include tips.texi 852 @include tips.texi
636 @include contrib.texi 853 @include contrib.texi
638 @include install.texi 855 @include install.texi
639 @include emacs.texi 856 @include emacs.texi
640 @c @include grammar.texi 857 @c @include grammar.texi
641 @include gpl.texi 858 @include gpl.texi
642 859
860 @c ------------------------------------------------------------------------
861 @c Indices start here.
862
643 @include cp-idx.texi 863 @include cp-idx.texi
644 @c @include vr-idx.texi 864 @c @include vr-idx.texi
645 @include fn-idx.texi 865 @include fn-idx.texi
646 @include op-idx.texi 866 @include op-idx.texi
647 867