----
Copyright © 1996-2013 John W. Eaton.
Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.
Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions.
Table of Contents
    Preface
        Acknowledgements
        Citing Octave in Publications
        How You Can Contribute to Octave
        Distribution
    1 A Brief Introduction to Octave
        1.1 Running Octave
        1.2 Simple Examples
            1.2.1 Elementary Calculations
            1.2.2 Creating a Matrix
            1.2.3 Matrix Arithmetic
            1.2.4 Solving Systems of Linear Equations
            1.2.5 Integrating Differential Equations
            1.2.6 Producing Graphical Output
            1.2.7 Editing What You Have Typed
            1.2.8 Help and Documentation
        1.3 Conventions
            1.3.1 Fonts
            1.3.2 Evaluation Notation
            1.3.3 Printing Notation
            1.3.4 Error Messages
            1.3.5 Format of Descriptions
                1.3.5.1 A Sample Function Description
                1.3.5.2 A Sample Command Description
    2 Getting Started
        2.1 Invoking Octave from the Command Line
            2.1.1 Command Line Options
            2.1.2 Startup Files
        2.2 Quitting Octave
        2.3 Commands for Getting Help
        2.4 Command Line Editing
            2.4.1 Cursor Motion
            2.4.2 Killing and Yanking
            2.4.3 Commands For Changing Text
            2.4.4 Letting Readline Type For You
            2.4.5 Commands For Manipulating The History
            2.4.6 Customizing readline
            2.4.7 Customizing the Prompt
            2.4.8 Diary and Echo Commands
        2.5 How Octave Reports Errors
        2.6 Executable Octave Programs
        2.7 Comments in Octave Programs
            2.7.1 Single Line Comments
            2.7.2 Block Comments
            2.7.3 Comments and the Help System
    3 Data Types
        3.1 Built-in Data Types
            3.1.1 Numeric Objects
            3.1.2 Missing Data
            3.1.3 String Objects
            3.1.4 Data Structure Objects
            3.1.5 Cell Array Objects
        3.2 User-defined Data Types
        3.3 Object Sizes
    4 Numeric Data Types
        4.1 Matrices
            4.1.1 Empty Matrices
        4.2 Ranges
        4.3 Single Precision Data Types
        4.4 Integer Data Types
            4.4.1 Integer Arithmetic
        4.5 Bit Manipulations
        4.6 Logical Values
        4.7 Promotion and Demotion of Data Types
        4.8 Predicates for Numeric Objects
    5 Strings
        5.1 Escape Sequences in String Constants
        5.2 Character Arrays
        5.3 Creating Strings
            5.3.1 Concatenating Strings
            5.3.2 Converting Numerical Data to Strings
        5.4 Comparing Strings
        5.5 Manipulating Strings
        5.6 String Conversions
        5.7 Character Class Functions
    6 Data Containers
        6.1 Structures
            6.1.1 Basic Usage and Examples
            6.1.2 Structure Arrays
            6.1.3 Creating Structures
            6.1.4 Manipulating Structures
            6.1.5 Processing Data in Structures
        6.2 Cell Arrays
            6.2.1 Basic Usage of Cell Arrays
            6.2.2 Creating Cell Arrays
            6.2.3 Indexing Cell Arrays
            6.2.4 Cell Arrays of Strings
            6.2.5 Processing Data in Cell Arrays
        6.3 Comma Separated Lists
            6.3.1 Comma Separated Lists Generated from Cell Arrays
            6.3.2 Comma Separated Lists Generated from Structure Arrays
    7 Variables
        7.1 Global Variables
        7.2 Persistent Variables
        7.3 Status of Variables
    8 Expressions
        8.1 Index Expressions
            8.1.1 Advanced Indexing
        8.2 Calling Functions
            8.2.1 Call by Value
            8.2.2 Recursion
        8.3 Arithmetic Operators
        8.4 Comparison Operators
        8.5 Boolean Expressions
            8.5.1 Element-by-element Boolean Operators
            8.5.2 Short-circuit Boolean Operators
        8.6 Assignment Expressions
        8.7 Increment Operators
        8.8 Operator Precedence
    9 Evaluation
        9.1 Calling a Function by its Name
        9.2 Evaluation in a Different Context
    10 Statements
        10.1 The if Statement
        10.2 The switch Statement
            10.2.1 Notes for the C Programmer
        10.3 The while Statement
        10.4 The do-until Statement
        10.5 The for Statement
            10.5.1 Looping Over Structure Elements
        10.6 The break Statement
        10.7 The continue Statement
        10.8 The unwind_protect Statement
        10.9 The try Statement
        10.10 Continuation Lines
    11 Functions and Scripts
        11.1 Introduction to Function and Script Files
        11.2 Defining Functions
        11.3 Multiple Return Values
        11.4 Variable-length Argument Lists
        11.5 Ignoring Arguments
        11.6 Variable-length Return Lists
        11.7 Returning from a Function
        11.8 Default Arguments
        11.9 Function Files
            11.9.1 Manipulating the Load Path
            11.9.2 Subfunctions
            11.9.3 Private Functions
            11.9.4 Nested Functions
            11.9.5 Overloading and Autoloading
            11.9.6 Function Locking
            11.9.7 Function Precedence
        11.10 Script Files
        11.11 Function Handles, Anonymous Functions, Inline Functions
            11.11.1 Function Handles
            11.11.2 Anonymous Functions
            11.11.3 Inline Functions
        11.12 Commands
        11.13 Organization of Functions Distributed with Octave
    12 Errors and Warnings
        12.1 Handling Errors
            12.1.1 Raising Errors
            12.1.2 Catching Errors
            12.1.3 Recovering From Errors
        12.2 Handling Warnings
            12.2.1 Issuing Warnings
            12.2.2 Enabling and Disabling Warnings
    13 Debugging
        13.1 Entering Debug Mode
        13.2 Leaving Debug Mode
        13.3 Breakpoints
        13.4 Debug Mode
        13.5 Call Stack
        13.6 Profiling
        13.7 Profiler Example
    14 Input and Output
        14.1 Basic Input and Output
            14.1.1 Terminal Output
                14.1.1.1 Paging Screen Output
            14.1.2 Terminal Input
            14.1.3 Simple File I/O
                14.1.3.1 Saving Data on Unexpected Exits
        14.2 C-Style I/O Functions
            14.2.1 Opening and Closing Files
            14.2.2 Simple Output
            14.2.3 Line-Oriented Input
            14.2.4 Formatted Output
            14.2.5 Output Conversion for Matrices
            14.2.6 Output Conversion Syntax
            14.2.7 Table of Output Conversions
            14.2.8 Integer Conversions
            14.2.9 Floating-Point Conversions
            14.2.10 Other Output Conversions
            14.2.11 Formatted Input
            14.2.12 Input Conversion Syntax
            14.2.13 Table of Input Conversions
            14.2.14 Numeric Input Conversions
            14.2.15 String Input Conversions
            14.2.16 Binary I/O
            14.2.17 Temporary Files
            14.2.18 End of File and Errors
            14.2.19 File Positioning
    15 Plotting
        15.1 Introduction to Plotting
        15.2 High-Level Plotting
            15.2.1 Two-Dimensional Plots
                15.2.1.1 Axis Configuration
                15.2.1.2 Two-dimensional Function Plotting
                15.2.1.3 Two-dimensional Geometric Shapes
            15.2.2 Three-Dimensional Plots
                15.2.2.1 Aspect Ratio
                15.2.2.2 Three-dimensional Function Plotting
                15.2.2.3 Three-dimensional Geometric Shapes
            15.2.3 Plot Annotations
            15.2.4 Multiple Plots on One Page
            15.2.5 Multiple Plot Windows
            15.2.6 Manipulation of Plot Windows
            15.2.7 Use of the interpreter Property
            15.2.8 Printing and Saving Plots
            15.2.9 Interacting with Plots
            15.2.10 Test Plotting Functions
        15.3 Graphics Data Structures
            15.3.1 Introduction to Graphics Structures
            15.3.2 Graphics Objects
                15.3.2.1 Creating Graphics Objects
                15.3.2.2 Handle Functions
            15.3.3 Graphics Object Properties
                15.3.3.1 Root Figure Properties
                15.3.3.2 Figure Properties
                15.3.3.3 Axes Properties
                15.3.3.4 Line Properties
                15.3.3.5 Text Properties
                15.3.3.6 Image Properties
                15.3.3.7 Patch Properties
                15.3.3.8 Surface Properties
            15.3.4 Searching Properties
            15.3.5 Managing Default Properties
        15.4 Advanced Plotting
            15.4.1 Colors
            15.4.2 Line Styles
            15.4.3 Marker Styles
            15.4.4 Callbacks
            15.4.5 Application-defined Data
            15.4.6 Object Groups
                15.4.6.1 Data Sources in Object Groups
                15.4.6.2 Area Series
                15.4.6.3 Bar Series
                15.4.6.4 Contour Groups
                15.4.6.5 Error Bar Series
                15.4.6.6 Line Series
                15.4.6.7 Quiver Group
                15.4.6.8 Scatter Group
                15.4.6.9 Stair Group
                15.4.6.10 Stem Series
                15.4.6.11 Surface Group
            15.4.7 Graphics Toolkits
                15.4.7.1 Customizing Toolkit Behavior
    16 Matrix Manipulation
        16.1 Finding Elements and Checking Conditions
        16.2 Rearranging Matrices
        16.3 Special Utility Matrices
        16.4 Famous Matrices
    17 Arithmetic
        17.1 Exponents and Logarithms
        17.2 Complex Arithmetic
        17.3 Trigonometry
        17.4 Sums and Products
        17.5 Utility Functions
        17.6 Special Functions
        17.7 Rational Approximations
        17.8 Coordinate Transformations
        17.9 Mathematical Constants
    18 Linear Algebra
        18.1 Techniques Used for Linear Algebra
        18.2 Basic Matrix Functions
        18.3 Matrix Factorizations
        18.4 Functions of a Matrix
        18.5 Specialized Solvers
    19 Vectorization and Faster Code Execution
        19.1 Basic Vectorization
        19.2 Broadcasting
            19.2.1 Broadcasting and Legacy Code
        19.3 Function Application
        19.4 Accumulation
        19.5 JIT Compiler
        19.6 Miscellaneous Techniques
        19.7 Examples
    20 Nonlinear Equations
        20.1 Solvers
        20.2 Minimizers
    21 Diagonal and Permutation Matrices
        21.1 Creating and Manipulating Diagonal/Permutation Matrices
            21.1.1 Creating Diagonal Matrices
            21.1.2 Creating Permutation Matrices
            21.1.3 Explicit and Implicit Conversions
        21.2 Linear Algebra with Diagonal/Permutation Matrices
            21.2.1 Expressions Involving Diagonal Matrices
            21.2.2 Expressions Involving Permutation Matrices
        21.3 Functions That Are Aware of These Matrices
            21.3.1 Diagonal Matrix Functions
            21.3.2 Permutation Matrix Functions
        21.4 Examples of Usage
        21.5 Differences in Treatment of Zero Elements
    22 Sparse Matrices
        22.1 Creation and Manipulation of Sparse Matrices
            22.1.1 Storage of Sparse Matrices
            22.1.2 Creating Sparse Matrices
            22.1.3 Finding Information about Sparse Matrices
            22.1.4 Basic Operators and Functions on Sparse Matrices
                22.1.4.1 Sparse Functions
                22.1.4.2 Return Types of Operators and Functions
                22.1.4.3 Mathematical Considerations
        22.2 Linear Algebra on Sparse Matrices
        22.3 Iterative Techniques Applied to Sparse Matrices
        22.4 Real Life Example using Sparse Matrices
    23 Numerical Integration
        23.1 Functions of One Variable
        23.2 Orthogonal Collocation
        23.3 Functions of Multiple Variables
    24 Differential Equations
        24.1 Ordinary Differential Equations
        24.2 Differential-Algebraic Equations
    25 Optimization
        25.1 Linear Programming
        25.2 Quadratic Programming
        25.3 Nonlinear Programming
        25.4 Linear Least Squares
    26 Statistics
        26.1 Descriptive Statistics
        26.2 Basic Statistical Functions
        26.3 Statistical Plots
        26.4 Correlation and Regression Analysis
        26.5 Distributions
        26.6 Tests
        26.7 Random Number Generation
    27 Sets
        27.1 Set Operations
    28 Polynomial Manipulations
        28.1 Evaluating Polynomials
        28.2 Finding Roots
        28.3 Products of Polynomials
        28.4 Derivatives / Integrals / Transforms
        28.5 Polynomial Interpolation
        28.6 Miscellaneous Functions
    29 Interpolation
        29.1 One-dimensional Interpolation
        29.2 Multi-dimensional Interpolation
    30 Geometry
        30.1 Delaunay Triangulation
            30.1.1 Plotting the Triangulation
            30.1.2 Identifying Points in Triangulation
        30.2 Voronoi Diagrams
        30.3 Convex Hull
        30.4 Interpolation on Scattered Data
    31 Signal Processing
    32 Image Processing
        32.1 Loading and Saving Images
        32.2 Displaying Images
        32.3 Representing Images
        32.4 Plotting on top of Images
        32.5 Color Conversion
    33 Audio Processing
    34 Object Oriented Programming
        34.1 Creating a Class
        34.2 Manipulating Classes
        34.3 Indexing Objects
            34.3.1 Defining Indexing And Indexed Assignment
            34.3.2 Indexed Assignment Optimization
        34.4 Overloading Objects
            34.4.1 Function Overloading
            34.4.2 Operator Overloading
            34.4.3 Precedence of Objects
        34.5 Inheritance and Aggregation
    35 GUI Development
        35.1 I/O Dialogs
        35.2 Progress Bar
        35.3 GUI Utility Functions
        35.4 User-Defined Preferences
    36 System Utilities
        36.1 Timing Utilities
        36.2 Filesystem Utilities
        36.3 File Archiving Utilities
        36.4 Networking Utilities
            36.4.1 FTP Objects
            36.4.2 URL Manipulation
            36.4.3 Base64 and Binary Data Transmission
        36.5 Controlling Subprocesses
        36.6 Process, Group, and User IDs
        36.7 Environment Variables
        36.8 Current Working Directory
        36.9 Password Database Functions
        36.10 Group Database Functions
        36.11 System Information
        36.12 Hashing Functions
    37 Java Interface
        37.1 Java Interface Functions
        37.2 Dialog Box Functions
        37.3 FAQ - Frequently asked Questions
            37.3.1 How to distinguish between Octave and Matlab?
            37.3.2 How to make Java classes available to Octave?
            37.3.3 How to create an instance of a Java class?
            37.3.4 How can I handle memory limitations?
            37.3.5 Which TeX symbols are implemented in dialog functions?
    38 Packages
        38.1 Installing and Removing Packages
        38.2 Using Packages
        38.3 Administrating Packages
        38.4 Creating Packages
            38.4.1 The DESCRIPTION File
            38.4.2 The INDEX File
            38.4.3 PKG_ADD and PKG_DEL Directives
            38.4.4 Missing Components
    Appendix A External Code Interface
        A.1 Oct-Files
            A.1.1 Getting Started with Oct-Files
            A.1.2 Matrices and Arrays in Oct-Files
            A.1.3 Character Strings in Oct-Files
            A.1.4 Cell Arrays in Oct-Files
            A.1.5 Structures in Oct-Files
            A.1.6 Sparse Matrices in Oct-Files
                A.1.6.1 Array and Sparse Class Differences
                A.1.6.2 Creating Sparse Matrices in Oct-Files
                A.1.6.3 Using Sparse Matrices in Oct-Files
            A.1.7 Accessing Global Variables in Oct-Files
            A.1.8 Calling Octave Functions from Oct-Files
            A.1.9 Calling External Code from Oct-Files
            A.1.10 Allocating Local Memory in Oct-Files
            A.1.11 Input Parameter Checking in Oct-Files
            A.1.12 Exception and Error Handling in Oct-Files
            A.1.13 Documentation and Test of Oct-Files
        A.2 Mex-Files
            A.2.1 Getting Started with Mex-Files
            A.2.2 Working with Matrices and Arrays in Mex-Files
            A.2.3 Character Strings in Mex-Files
            A.2.4 Cell Arrays with Mex-Files
            A.2.5 Structures with Mex-Files
            A.2.6 Sparse Matrices with Mex-Files
            A.2.7 Calling Other Functions in Mex-Files
        A.3 Standalone Programs
    Appendix B Test and Demo Functions
        B.1 Test Functions
        B.2 Demonstration Functions
    Appendix C Tips and Standards
        C.1 Writing Clean Octave Programs
        C.2 Tips on Writing Comments
        C.3 Conventional Headers for Octave Functions
        C.4 Tips for Documentation Strings
    Appendix D Contributing Guidelines
        D.1 How to Contribute
        D.2 Building the Development Sources
        D.3 Basics of Generating a Changeset
        D.4 General Guidelines
        D.5 Octave Sources (m-files)
        D.6 C++ Sources
        D.7 Other Sources
    Appendix E Obsolete Functions
    Appendix F Known Causes of Trouble
        F.1 Actual Bugs We Haven’t Fixed Yet
        F.2 Reporting Bugs
            F.2.1 Have You Found a Bug?
            F.2.2 Where to Report Bugs
            F.2.3 How to Report Bugs
            F.2.4 Sending Patches for Octave
        F.3 How To Get Help with Octave
    Appendix G Installing Octave
        G.1 Build Dependencies
            G.1.1 Obtaining the Dependencies Automatically
            G.1.2 Build Tools
            G.1.3 External Packages
        G.2 Running Configure and Make
        G.3 Compiling Octave with 64-bit Indexing
        G.4 Installation Problems
    Appendix H Emacs Octave Support
        H.1 Installing EOS
        H.2 Using Octave Mode
        H.3 Running Octave from Within Emacs
        H.4 Using the Emacs Info Reader for Octave
    Appendix I Grammar and Parser
        I.1 Keywords
        I.2 Parser
    Appendix J GNU GENERAL PUBLIC LICENSE
    Concept Index
    Function Index
    Operator Index
---
Next: Preface, Up: (dir)   [Contents][Index]
This manual documents how to run, install and port GNU Octave, as well as its new features and incompatibilities, and how to report bugs. It corresponds to GNU Octave version 3.8.0.
 • Preface:	  	
 • Introduction:	  	A brief introduction to Octave.
 • Getting Started:	  	
 • Data Types:	  	
 • Numeric Data Types:	  	
 • Strings:	  	
 • Data Containers:	  	
 • Variables:	  	
 • Expressions:	  	
 • Evaluation:	  	
 • Statements:	  	Looping and program flow control.
 • Functions and Scripts:	  	
 • Errors and Warnings:	  	
 • Debugging:	  	
 • Input and Output:	  	
 • Plotting:	  	
 • Matrix Manipulation:	  	
 • Arithmetic:	  	
 • Linear Algebra:	  	
 • Vectorization and Faster Code Execution:	  	
 • Nonlinear Equations:	  	
 • Diagonal and Permutation Matrices:	  	
 • Sparse Matrices:	  	
 • Numerical Integration:	  	
 • Differential Equations:	  	
 • Optimization:	  	
 • Statistics:	  	
 • Sets:	  	
 • Polynomial Manipulations:	  	
 • Interpolation:	  	
 • Geometry:	  	
 • Signal Processing:	  	
 • Image Processing:	  	
 • Audio Processing:	  	
 • Object Oriented Programming:	  	
 • GUI Development:	  	
 • System Utilities:	  	
 • Java Interface:	  	
 • Packages:	  	
 • External Code Interface:	  	
 • Test and Demo Functions:	  	
 • Tips and Standards:	  	
 • Contributing Guidelines:	  	
 • Obsolete Functions:	  	
 • Trouble:	  	If you have trouble installing Octave.
 • Installation:	  	How to configure, compile and install Octave.
 • Emacs Octave Support:	  	
 • Grammar and Parser:	  	
 • Copying:	  	The GNU General Public License.
 • Concept Index:	  	An item for each concept.
 • Function Index:	  	An item for each documented function.
 • Operator Index:	  	An item for each documented operator.
---
 — The Detailed Node Listing —
 Preface
 
 • Acknowledgements:	  	
 • Citing Octave in Publications:	  	
 • How You Can Contribute to Octave:	  	
 • Distribution:	  	
 
 Introduction
 
 • Running Octave:	  	
 • Simple Examples:	  	
 • Conventions:	  	
 
 Conventions
 
 • Fonts:	  	
 • Evaluation Notation:	  	
 • Printing Notation:	  	
 • Error Messages:	  	
 • Format of Descriptions:	  	
 
 Format of Descriptions
 
 • A Sample Function Description:	  	
 • A Sample Command Description:	  	
 
 Getting Started
 
 • Invoking Octave from the Command Line:	  	
 • Quitting Octave:	  	
 • Getting Help:	  	
 • Command Line Editing:	  	
 • Errors:	  	
 • Executable Octave Programs:	  	
 • Comments:	  	
 
 Invoking Octave from the Command Line
 
 • Command Line Options:	  	
 • Startup Files:	  	
 
 Command Line Editing
 
 • Cursor Motion:	  	
 • Killing and Yanking:	  	
 • Commands For Text:	  	
 • Commands For Completion:	  	
 • Commands For History:	  	
 • Customizing readline:	  	
 • Customizing the Prompt:	  	
 • Diary and Echo Commands:	  	
 
 Comments
 
 • Single Line Comments:	  	
 • Block Comments:	  	
 • Comments and the Help System:	  	
 
 Data Types
 
 • Built-in Data Types:	  	
 • User-defined Data Types:	  	
 • Object Sizes:	  	
 
 Built-in Data Types
 
 • Numeric Objects:	  	
 • Missing Data:	  	
 • String Objects:	  	
 • Data Structure Objects:	  	
 • Cell Array Objects:	  	
 
 Numeric Data Types
 
 • Matrices:	  	
 • Ranges:	  	
 • Single Precision Data Types:	  	
 • Integer Data Types:	  	
 • Bit Manipulations:	  	
 • Logical Values:	  	
 • Promotion and Demotion of Data Types:	  	
 • Predicates for Numeric Objects:	  	
 
 Matrices
 
 • Empty Matrices:	  	
 
 Integer Data Types
 
 • Integer Arithmetic:	  	
 
 Strings
 
 • Escape Sequences in String Constants:	  	
 • Character Arrays:	  	
 • Creating Strings:	  	
 • Comparing Strings:	  	
 • Manipulating Strings:	  	
 • String Conversions:	  	
 • Character Class Functions:	  	
 
 Creating Strings
 
 • Concatenating Strings:	  	
 • Converting Numerical Data to Strings:	  	
 
 Data Containers
 
 • Structures:	  	
 • Cell Arrays:	  	
 • Comma Separated Lists:	  	
 
 Structures
 
 • Basic Usage and Examples:	  	
 • Structure Arrays:	  	
 • Creating Structures:	  	
 • Manipulating Structures:	  	
 • Processing Data in Structures:	  	
 
 Cell Arrays
 
 • Basic Usage of Cell Arrays:	  	
 • Creating Cell Arrays:	  	
 • Indexing Cell Arrays:	  	
 • Cell Arrays of Strings:	  	
 • Processing Data in Cell Arrays:	  	
 
 Comma Separated Lists
 
 • Comma Separated Lists Generated from Cell Arrays:	  	
 • Comma Separated Lists Generated from Structure Arrays:	  	
 
 Variables
 
 • Global Variables:	  	
 • Persistent Variables:	  	
 • Status of Variables:	  	
 
 Expressions
 
 • Index Expressions:	  	
 • Calling Functions:	  	
 • Arithmetic Ops:	  	
 • Comparison Ops:	  	
 • Boolean Expressions:	  	
 • Assignment Ops:	  	
 • Increment Ops:	  	
 • Operator Precedence:	  	
 
 Index Expressions
 
 • Advanced Indexing:	  	
 
 Calling Functions
 
 • Call by Value:	  	
 • Recursion:	  	
 
 Boolean Expressions
 
 • Element-by-element Boolean Operators:	  	
 • Short-circuit Boolean Operators:	  	
 
 Evaluation
 
 • Calling a Function by its Name:	  	
 • Evaluation in a Different Context:	  	
 
 Statements
 
 • The if Statement:	  	
 • The switch Statement:	  	
 • The while Statement:	  	
 • The do-until Statement:	  	
 • The for Statement:	  	
 • The break Statement:	  	
 • The continue Statement:	  	
 • The unwind_protect Statement:	  	
 • The try Statement:	  	
 • Continuation Lines:	  	
 
 The switch Statement
 
 • Notes for the C Programmer:	  	
 
 The for Statement
 
 • Looping Over Structure Elements:	  	
 
 Functions and Scripts
 
 • Introduction to Function and Script Files:	  	
 • Defining Functions:	  	
 • Multiple Return Values:	  	
 • Variable-length Argument Lists:	  	
 • Ignoring Arguments:	  	
 • Variable-length Return Lists:	  	
 • Returning from a Function:	  	
 • Default Arguments:	  	
 • Function Files:	  	
 • Script Files:	  	
 • Function Handles Anonymous Functions Inline Functions:	  	
 • Commands:	  	
 • Organization of Functions:	  	
 
 Function Files
 
 • Manipulating the Load Path:	  	
 • Subfunctions:	  	
 • Private Functions:	  	
 • Nested Functions:	  	
 • Overloading and Autoloading:	  	
 • Function Locking:	  	
 • Function Precedence:	  	
 
 Function Handles Anonymous Functions Inline Functions
 
 • Function Handles:	  	
 • Anonymous Functions:	  	
 • Inline Functions:	  	
 
 Errors and Warnings
 
 • Handling Errors:	  	
 • Handling Warnings:	  	
 
 Handling Errors
 
 • Raising Errors:	  	
 • Catching Errors:	  	
 • Recovering From Errors:	  	
 
 Handling Warnings
 
 • Issuing Warnings:	  	
 • Enabling and Disabling Warnings:	  	
 
 Debugging
 
 • Entering Debug Mode:	  	
 • Leaving Debug Mode:	  	
 • Breakpoints:	  	
 • Debug Mode:	  	
 • Call Stack:	  	
 • Profiling:	  	
 • Profiler Example:	  	
 
 Input and Output
 
 • Basic Input and Output:	  	
 • C-Style I/O Functions:	  	
 
 Basic Input and Output
 
 • Terminal Output:	  	
 • Terminal Input:	  	
 • Simple File I/O:	  	
 
 Terminal Output
 
 • Paging Screen Output:	  	
 
 Simple File I/O
 
 • Saving Data on Unexpected Exits:	  	
 
 C-Style I/O Functions
 
 • Opening and Closing Files:	  	
 • Simple Output:	  	
 • Line-Oriented Input:	  	
 • Formatted Output:	  	
 • Output Conversion for Matrices:	  	
 • Output Conversion Syntax:	  	
 • Table of Output Conversions:	  	
 • Integer Conversions:	  	
 • Floating-Point Conversions:	  	
 • Other Output Conversions:	  	
 • Formatted Input:	  	
 • Input Conversion Syntax:	  	
 • Table of Input Conversions:	  	
 • Numeric Input Conversions:	  	
 • String Input Conversions:	  	
 • Binary I/O:	  	
 • Temporary Files:	  	
 • EOF and Errors:	  	
 • File Positioning:	  	
 
 Plotting
 
 • Introduction to Plotting:	  	
 • High-Level Plotting:	  	
 • Graphics Data Structures:	  	
 • Advanced Plotting:	  	
 
 High-Level Plotting
 
 • Two-Dimensional Plots:	  	
 • Three-Dimensional Plots:	  	
 • Plot Annotations:	  	
 • Multiple Plots on One Page:	  	
 • Multiple Plot Windows:	  	
 • Manipulation of Plot Windows:	  	
 • Use of the interpreter Property:	  	
 • Printing and Saving Plots:	  	
 • Interacting with Plots:	  	
 • Test Plotting Functions:	  	
 
 Two-Dimensional Plots
 
 • Axis Configuration:	  	
 • Two-dimensional Function Plotting:	  	
 • Two-dimensional Geometric Shapes:	  	
 
 Three-Dimensional Plots
 
 • Aspect Ratio:	  	
 • Three-dimensional Function Plotting:	  	
 • Three-dimensional Geometric Shapes:	  	
 
 Graphics Data Structures
 
 • Introduction to Graphics Structures:	  	
 • Graphics Objects:	  	
 • Graphics Object Properties:	  	
 • Searching Properties:	  	
 • Managing Default Properties:	  	
 
 Graphics Object Properties
 
 • Root Figure Properties:	  	
 • Figure Properties:	  	
 • Axes Properties:	  	
 • Line Properties:	  	
 • Text Properties:	  	
 • Image Properties:	  	
 • Patch Properties:	  	
 • Surface Properties:	  	
 
 Advanced Plotting
 
 • Colors:	  	
 • Line Styles:	  	
 • Marker Styles:	  	
 • Callbacks:	  	
 • Application-defined Data:	  	
 • Object Groups:	  	
 • Graphics Toolkits:	  	
 
 Object Groups
 
 • Data Sources in Object Groups:	  	
 • Area Series:	  	
 • Bar Series:	  	
 • Contour Groups:	  	
 • Error Bar Series:	  	
 • Line Series:	  	
 • Quiver Group:	  	
 • Scatter Group:	  	
 • Stair Group:	  	
 • Stem Series:	  	
 • Surface Group:	  	
 
 Graphics Toolkits
 
 • Customizing Toolkit Behavior:	  	
 
 Matrix Manipulation
 
 • Finding Elements and Checking Conditions:	  	
 • Rearranging Matrices:	  	
 • Special Utility Matrices:	  	
 • Famous Matrices:	  	
 
 Arithmetic
 
 • Exponents and Logarithms:	  	
 • Complex Arithmetic:	  	
 • Trigonometry:	  	
 • Sums and Products:	  	
 • Utility Functions:	  	
 • Special Functions:	  	
 • Rational Approximations:	  	
 • Coordinate Transformations:	  	
 • Mathematical Constants:	  	
 
 Linear Algebra
 
 • Techniques Used for Linear Algebra:	  	
 • Basic Matrix Functions:	  	
 • Matrix Factorizations:	  	
 • Functions of a Matrix:	  	
 • Specialized Solvers:	  	
 
 Vectorization and Faster Code Execution
 
 • Basic Vectorization:	  	Basic techniques for code optimization
 • Broadcasting:	  	Broadcasting operations
 • Function Application:	  	Applying functions to arrays, cells, and structs
 • Accumulation:	  	Accumulation functions
 • JIT Compiler:	  	Just-In-Time Compiler for loops
 • Miscellaneous Techniques:	  	Other techniques for speeding up code
 • Examples:	  	
 
 Nonlinear Equations
 
 • Solvers:	  	
 • Minimizers:	  	
 
 Diagonal and Permutation Matrices
 
 • Basic Usage:	  	Creation and Manipulation of Diagonal/Permutation Matrices
 • Matrix Algebra:	  	Linear Algebra with Diagonal/Permutation Matrices
 • Function Support:	  	Functions That Are Aware of These Matrices
 • Example Code:	  	Examples of Usage
 • Zeros Treatment:	  	Differences in Treatment of Zero Elements
 
 Basic Usage
 
 • Creating Diagonal Matrices:	  	
 • Creating Permutation Matrices:	  	
 • Explicit and Implicit Conversions:	  	
 
 Matrix Algebra
 
 • Expressions Involving Diagonal Matrices:	  	
 • Expressions Involving Permutation Matrices:	  	
 
 Function Support
 
 • Diagonal Matrix Functions:	  	
 • Permutation Matrix Functions:	  	
 
 Sparse Matrices
 
 • Basics:	  	Creation and Manipulation of Sparse Matrices
 • Sparse Linear Algebra:	  	Linear Algebra on Sparse Matrices
 • Iterative Techniques:	  	Iterative Techniques
 • Real Life Example:	  	Using Sparse Matrices
 
 Basics
 
 • Storage of Sparse Matrices:	  	
 • Creating Sparse Matrices:	  	
 • Information:	  	
 • Operators and Functions:	  	
 
 Operators and Functions
 
 • Sparse Functions:	  	
 • Return Types of Operators and Functions:	  	
 • Mathematical Considerations:	  	
 
 Numerical Integration
 
 • Functions of One Variable:	  	
 • Orthogonal Collocation:	  	
 • Functions of Multiple Variables:	  	
 
 Differential Equations
 
 • Ordinary Differential Equations:	  	
 • Differential-Algebraic Equations:	  	
 
 Optimization
 
 • Linear Programming:	  	
 • Quadratic Programming:	  	
 • Nonlinear Programming:	  	
 • Linear Least Squares:	  	
 
 Statistics
 
 • Descriptive Statistics:	  	
 • Basic Statistical Functions:	  	
 • Statistical Plots:	  	
 • Correlation and Regression Analysis:	  	
 • Distributions:	  	
 • Tests:	  	
 • Random Number Generation:	  	
 
 Sets
 
 • Set Operations:	  	
 
 Polynomial Manipulations
 
 • Evaluating Polynomials:	  	
 • Finding Roots:	  	
 • Products of Polynomials:	  	
 • Derivatives / Integrals / Transforms:	  	
 • Polynomial Interpolation:	  	
 • Miscellaneous Functions:	  	
 
 Interpolation
 
 • One-dimensional Interpolation:	  	
 • Multi-dimensional Interpolation:	  	
 
 Geometry
 
 • Delaunay Triangulation:	  	
 • Voronoi Diagrams:	  	
 • Convex Hull:	  	
 • Interpolation on Scattered Data:	  	
 
 Delaunay Triangulation
 
 • Plotting the Triangulation:	  	
 • Identifying Points in Triangulation:	  	
 
 Image Processing
 
 • Loading and Saving Images:	  	
 • Displaying Images:	  	
 • Representing Images:	  	
 • Plotting on top of Images:	  	
 • Color Conversion:	  	
 
 Object Oriented Programming
 
 • Creating a Class:	  	
 • Manipulating Classes:	  	
 • Indexing Objects:	  	
 • Overloading Objects:	  	
 • Inheritance and Aggregation:	  	
 
 Indexing Objects
 
 • Defining Indexing And Indexed Assignment:	  	
 • Indexed Assignment Optimization:	  	
 
 Overloading Objects
 
 • Function Overloading:	  	
 • Operator Overloading:	  	
 • Precedence of Objects:	  	
 
 GUI Development
 
 • I/O Dialogs:	  	
 • Progress Bar:	  	
 • GUI Utility Functions:	  	
 • User-Defined Preferences:	  	
 
 System Utilities
 
 • Timing Utilities:	  	
 • Filesystem Utilities:	  	
 • File Archiving Utilities:	  	
 • Networking Utilities:	  	
 • Controlling Subprocesses:	  	
 • Process ID Information:	  	
 • Environment Variables:	  	
 • Current Working Directory:	  	
 • Password Database Functions:	  	
 • Group Database Functions:	  	
 • System Information:	  	
 • Hashing Functions:	  	
 
 Networking Utilities
 
 • FTP Objects:	  	
 • URL Manipulation:	  	
 • Base64 and Binary Data Transmission:	  	
 
 Java Interface
 
 • Java Interface Functions:	  	
 • Dialog Box Functions:	  	
 • FAQ - Frequently asked Questions:	  	
 
 FAQ - Frequently asked Questions
 
 • How to distinguish between Octave and Matlab?:	  	
 • How to make Java classes available?:	  	
 • How to create an instance of a Java class?:	  	
 • How can I handle memory limitations?:	  	
 • Which TeX symbols are implemented in dialog functions?:	  	
 
 Packages
 
 • Installing and Removing Packages:	  	
 • Using Packages:	  	
 • Administrating Packages:	  	
 • Creating Packages:	  	
 
 Creating Packages
 
 • The DESCRIPTION File:	  	
 • The INDEX File:	  	
 • PKG_ADD and PKG_DEL Directives:	  	
 • Missing Components:	  	
 
 External Code Interface
 
 • Oct-Files:	  	
 • Mex-Files:	  	
 • Standalone Programs:	  	
 
 Oct-Files
 
 • Getting Started with Oct-Files:	  	
 • Matrices and Arrays in Oct-Files:	  	
 • Character Strings in Oct-Files:	  	
 • Cell Arrays in Oct-Files:	  	
 • Structures in Oct-Files:	  	
 • Sparse Matrices in Oct-Files:	  	
 • Accessing Global Variables in Oct-Files:	  	
 • Calling Octave Functions from Oct-Files:	  	
 • Calling External Code from Oct-Files:	  	
 • Allocating Local Memory in Oct-Files:	  	
 • Input Parameter Checking in Oct-Files:	  	
 • Exception and Error Handling in Oct-Files:	  	
 • Documentation and Test of Oct-Files:	  	
 
 Sparse Matrices in Oct-Files
 
 • Array and Sparse Class Differences:	  	
 • Creating Sparse Matrices in Oct-Files:	  	
 • Using Sparse Matrices in Oct-Files:	  	
 
 Mex-Files
 
 • Getting Started with Mex-Files:	  	
 • Working with Matrices and Arrays in Mex-Files:	  	
 • Character Strings in Mex-Files:	  	
 • Cell Arrays with Mex-Files:	  	
 • Structures with Mex-Files:	  	
 • Sparse Matrices with Mex-Files:	  	
 • Calling Other Functions in Mex-Files:	  	
 
 Test and Demo Functions
 
 • Test Functions:	  	
 • Demonstration Functions:	  	
 
 Tips and Standards
 
 • Style Tips:	  	Writing clean and robust programs.
 • Comment Tips:	  	Conventions for writing comments.
 • Function Headers:	  	Standard headers for functions.
 • Documentation Tips:	  	Writing readable documentation strings.
 
 Contributing Guidelines
 
 • How to Contribute:	  	
 • Building the Development Sources:	  	
 • Basics of Generating a Changeset:	  	
 • General Guidelines:	  	
 • Octave Sources (m-files):	  	
 • C++ Sources:	  	
 • Other Sources:	  	
 
 Trouble
 
 • Actual Bugs:	  	Bugs we will fix later.
 • Reporting Bugs:	  	
 • Service:	  	
 
 Reporting Bugs
 
 • Bug Criteria:	  	
 • Bug Tracker:	  	Where to submit your bug report.
 • Bug Reporting:	  	How to report a bug effectively.
 • Sending Patches:	  	How to send a patch for Octave.
 
 Installation
 
 • Build Dependencies:	  	
 • Running Configure and Make:	  	
 • Compiling Octave with 64-bit Indexing:	  	
 • Installation Problems:	  	
 
 Build Dependencies
 
 • Obtaining the Dependencies Automatically:	  	
 • Build Tools:	  	
 • External Packages:	  	
 
 Emacs Octave Support
 
 • Installing EOS:	  	
 • Using Octave Mode:	  	
 • Running Octave from Within Emacs:	  	
 • Using the Emacs Info Reader for Octave:	  	
 
 Grammar and Parser
 
 • Keywords:	  	
 • Parser:	  	
---
 Next: Preface, Up: (dir)   [Contents][Index]
----
Copyright © 1996-2013 John W. Eaton. [http://www.gnu.org/software/octave/doc/interpreter/ GNU Octave](GNU Octaveマニュアルのオリジナルページ)
Copyright (C) 2005-2007 [http://www.obihiro.ac.jp/~suzukim/masuda/octave/octave_ja.html MASUDA, Yutaka](日本語訳)
Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.
Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions.