GNU Octave 3.8.x 日本語マニュアル

出典: フリー教科書『ウィキブックス(Wikibooks)』
ナビゲーションに移動 検索に移動

メインページ > 工学 > 情報技術 > プログラミング > GNU Octave > GNU Octave 3.8.x 日本語マニュアル


Wikipedia
ウィキペディアGNU Octaveの記事があります。


このページ「GNU Octave 3.8.x 日本語マニュアル」は、まだ書きかけです。加筆・訂正など、協力いただける皆様の編集を心からお待ちしております。また、ご意見などがありましたら、お気軽にトークページへどうぞ。

GNU Octave[編集]

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. GNU Octave(GNU Octaveマニュアルのオリジナルページ)
Copyright (C) 2005-2007 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.