Octave Quick Reference

Octave Version 3.0.0

Starting Octave
octave
start interactive Octave session
octave file
run Octave on commands in file
octave --eval code Evaluate code using Octave
octave --help
describe command line options

Killing and Yanking

C-k
C-y
M-d
M-DEL
M-y

kill to the end of the line

yank the most recently killed text
kill to the end of the current word
kill the word behind the cursor
rotate the kill ring and yank the new top

Command Completion and History

Stopping Octave
quit or exit
INTERRUPT

exit Octave
(e.g. C-c) terminate current command
and return to top-level prompt

Getting Help
help
help command
doc
doc command
lookfor str

list all commands and built-in variables

briefly describe command
use Info to browse Octave manual
search for command in Octave manual
search for command based on str

scroll forward one screenful

scroll backward one screenful
redraw the display

Node Selection in Info

n
p
u
t
d
<
>
g
C-x k

select the next node

select the previous node
select the up node
select the top node
select the directory node
select the first node in the current file
select the last node in the current file
reads the name of a node and selects it
kills the current node

Searching in Info
s
C-s
C-r
i
,

search for a string

search forward incrementally
search backward incrementally
search index & go to corresponding node
go to next match from last i command

Command-Line Cursor Motion

C-b
C-f
C-a
C-e
M-f
M-b
C-l

move back one character

move forward one character
move to the start of the line
move to the end of the line
move forward a word
move backward a word
clear screen, reprinting current line at top

Inserting or Changing Text

M-TAB
DEL
C-d
C-v
C-t
M-t

[]

insert a tab character

delete character to the left of the cursor
delete character under the cursor
add the next character verbatim
transpose characters at the point
transpose words at the point

surround optional arguments

... show one or more arguments

Sparse Matrices
sparse (...)
speye (n)
sprand (n, m, d)
spdiags (...)
nnz (s)

create a sparse matrix.

create sparse identity matrix.
sparse rand matrix of density d.
sparse generalization of diag.
No. nonzero elements in sparse matrix.

TAB
M-?
RET
C-p
C-n
M-<
M->
C-r
C-s
history [-q] [N ]

complete a command or variable name

list possible completions
enter the current line
move up through the history list
move down through the history list
move to the first line in the history
move to the last line in the history
search backward in the history list
search forward in the history list
list N previous history lines, omitting
history numbers if -q

Strings and Common Escape Sequences

history -w [file]

write history to file (~/.octave hist if

no file argument)

A string constant consists of a sequence of characters enclosed

in either double-quote or single-quote marks. Strings in
double-quotes allow the use of the escape sequences below.

Motion in Info
SPC or C-v
DEL or M-v
C-l

shiftdim (arr, s) rotate the array dimensions.

circshift (arr, s) rotate the array elements.

history -r [file]

read history from file (~/.octave hist if

no file argument)
edit history lines edit and then run previous commands
from the history list
run history lines run previous commands from the history
list

[beg ] [end ]

Specify the first and last history

commands to edit or run.
If beg is greater than end, reverse the list of commands
before editing. If end is omitted, select commands from
beg to the end of the history list. If both arguments are
omitted, edit the previous item in the history list.

Ranges
base : limit
base : incr : limit
Specify a range of values beginning with base with no
elements greater than limit. If it is omitted, the default
value of incr is 1. Negative increments are permitted.

\\
\"
\
\n
\t

Index Expressions
var (idx)
var (idx1, idx2)
scalar
vector

Shell Commands
cd dir
pwd

change working directory to dir

print working directory

ls [options]
getenv (string)

print directory listing

system (cmd)

return value of named environment

variable
execute arbitrary shell command string

Matrices
Square brackets delimit literal matrices. Commas separate
elements on the same row. Semicolons separate rows. Commas
may be replaced by spaces, and semicolons may be replaced by
one or more newlines. Elements of a matrix may be arbitrary
expressions, assuming all the dimensions agree.

[ x, y, ... ]
[ x; y; ... ]
[ w, x; y, z ]

enter a row vector

enter a column vector
enter a 22 matrix

Multi-dimensional Arrays
Multi-dimensional arrays may be created with the cat or
reshape commands from two-dimensional sub-matrices.

squeeze (arr)
ndims (arr)
permute (arr, p)
ipermute (arr, p)

remove singleton dimensions of the array.

number of dimensions in the array.
permute the dimensions of an array.
array inverse permutation.

a literal backslash
a literal double-quote character
a literal single-quote character
newline, ASCII code 10
horizontal tab, ASCII code 9

range

select elements of a vector

select elements of a matrix
select row (column) corresponding to
scalar
select rows (columns) corresponding to the
elements of vector
select rows (columns) corresponding to the
elements of range
select all rows (columns)

Global and Persistent Variables

global var1 ...
global var1 = val
persistent var1
persistent var1 =

Declare variables global.

Declare variable global. Set initial value.
Declare a variable as static to a function.
Declare a variable as static to a function
val
and set its initial value.
Global variables may be accessed inside the body of a function
without having to be passed in the function parameter list
provided they are declared global when used.

Selected Built-in Functions

EDITOR
Inf, NaN
NA
PAGER
ans
eps
pi
1i
realmax
realmin

editor to use with edit history

IEEE infinity, NaN
Missing value
program to use to paginate output
last result not explicitly assigned
machine precision

maximum representable value

minimum representable value

Copyright 1996, 1997, 2007 John W. Eaton

Permissions on back

Assignment Expressions

Paths and Packages

Function Handles

var = expr
var (idx) = expr
var (idx) = []

path
pathdef
addpath (dir)
EXEC PATH
pkg list
pkg load pack

@func
Define a function handle to func.
@(var1, ...) expr Define an anonymous function handle.
str2func (str)
Create a function handle from a string.
functions (handle) Return information about a function

var

{idx} =

expr

assign expression to variable

assign expression to indexed variable
delete the indexed elements.
assign elements of a cell array.

Arithmetic and Increment Operators

x
x
x
x
x

+ y
- y
* y
.* y
/ y

addition
subtraction
matrix multiplication
element by element multiplication
right division, conceptually equivalent to

(inverse (y) * x)
x ./ y
x \ y

element by element right division

left division, conceptually equivalent to

x .\ y
x ^ y
x .^ y
- x
+ x
x
x .
++ x (-- x)
x ++ (x --)

element by element left division

power operator
element by element power operator
negation
unary plus (a no-op)
complex conjugate transpose
transpose
increment (decrement), return new value
increment (decrement), return old value

inverse (x) * y

Comparison and Boolean Operators

These operators work on an element-by-element basis. Both
arguments are always evaluated.
x
x
x
x
x
x
x
x

< y
<= y
== y
>= y
> y
!= y
& y
| y

! bool

true
true
true
true
true
true
true
true
true

if
if
if
if
if
if
if
if
if

x is less than y
x is less than or equal to y
x is equal to y
x is greater than or equal to y
x is greater than y
x is not equal to y
both x and y are true
at least one of x or y is true
bool is false

Short-circuit Boolean Operators

Operators evaluate left-to-right. Operands are only evaluated if
necessary, stopping once overall truth value can be determined.
Operands are converted to scalars using the all function.
x && y
x || y

true if both x and y are true

true if at least one of x or y is true

Operator Precedence
Table of Octave operators, in order of increasing precedence.

; ,
=
|| &&
| &
< <= == >= > !=
:
+ * / \ .* ./ .\
.
+ - ++ -- !
^ .^

statement separators
assignment, groups left to right
logical or and and
element-wise or and and
relational operators
colon
addition and subtraction
multiplication and division
transpose
unary minus, increment, logical not
exponentiation

display the current Octave function path.

display the default path.
add a directory to the path.
manipulate the Octave executable path.
display installed packages.
Load an installed package.

Cells and Structures

var.field = ...

set a field of a structure.

var{idx} = ...

set an element of a cell array.

cellfun (f, c)
fieldnames (s)

apply a function to elements of cell array.

returns the fields of a structure.

function handle.
handle (arg1, ...) Evaluate a function handle.
feval (func, arg1, Evaluate a function handle or string,
...)
passing remaining args to func
Anonymous function handles take a copy of the variables in
the current workspace.

Miscellaneous Functions

Statements
for identifier = expr stmt-list endfor
Execute stmt-list once for each column of expr. The
variable identifier is set to the value of the current column
during each iteration.

while (condition) stmt-list endwhile

Execute stmt-list while condition is true.

break
continue
return

handle.

func2str (handle) Return a string representation of a

exit innermost loop

go to beginning of innermost loop
return to calling function

eval (str)
error (message)
warning (message)
clear pattern
exist (str)
who, whos
whos var

evaluate str as a command

print message and return to top level
print a warning message
clear variables matching pattern
check existence of variable or function
list current variables
details of the variable var

Basic Matrix Manipulations

rows (a)
columns (a)
all (a)
any (a)

return number of rows of a

return number of columns of a
check if all elements of a nonzero
check if any elements of a nonzero

if (condition) if-body [else else-body] endif

Execute if-body if condition is true, otherwise execute elsebody.

if (condition) if-body [elseif (condition) elseif-body] endif

Execute if-body if condition is true, otherwise execute the
elseif-body corresponding to the first elseif condition that
is true, otherwise execute else-body.
Any number of elseif clauses may appear in an if
statement.

unwind protect body unwind protect cleanup cleanup end

Execute body. Execute cleanup no matter how control exits
body.
try body catch cleanup end
Execute body. Execute cleanup if body fails.

find (a)
return indices of nonzero elements
sort (a)
order elements in each column of a
sum (a)
sum elements in columns of a
prod (a)
product of elements in columns of a
min (args)
find minimum values
max (args)
find maximum values
rem (x, y)
find remainder of x/y
reshape (a, m, n) reformat a to be m by n
diag (v, k)
create diagonal matrices
linspace (b, l, n) create vector of linearly-spaced elements
logspace (b, l, n) create vector of log-spaced elements
eye (n, m)
create n by m identity matrix
ones (n, m)
create n by m matrix of ones
zeros (n, m)
create n by m matrix of zeros
rand (n, m)
create n by m matrix of random values

Strings
strcmp (s, t)
strcat (s, t, ...)
regexp (str, pat)
regexprep (str, pat, rep)

compare strings
concatenate strings
strings matching regular expression
Match and replace sub-strings

Defining Functions
function [ret-list] function-name [ (arg-list) ]
function-body

endfunction
ret-list may be a single identifier or a comma-separated list of
identifiers delimited by square-brackets.
arg-list is a comma-separated list of identifiers and may be
empty.

Linear Algebra
chol (a)
det (a)
eig (a)
expm (a)
hess (a)
inverse (a)
norm (a, p)
pinv (a)
qr (a)
rank (a)
sprank (a)
schur (a)
svd (a)
syl (a, b, c)

Cholesky factorization
compute the determinant of a matrix
eigenvalues and eigenvectors
compute the exponential of a matrix
compute Hessenberg decomposition
invert a square matrix
compute the p-norm of a matrix
compute pseudoinverse of a
compute the QR factorization of a matrix
matrix rank
structural matrix rank
Schur decomposition of a matrix
singular value decomposition
solve the Sylvester equation

Equations, ODEs, DAEs, Quadrature

*fsolve
*lsode
*dassl
*quad
perror (nm, code)

solve nonlinear algebraic equations

integrate nonlinear ODEs
integrate nonlinear DAEs
integrate nonlinear functions
for functions that return numeric codes,
print error message for named function
and given error code

* See the on-line or printed manual for the complete list of

arguments for these functions.

Signal Processing
fft (a)
ifft (a)
freqz (args)
filter (a, b, x)
conv (a, b)
hamming (n)
hanning (n)

Fast Fourier Transform using FFTW

inverse FFT using FFTW
FIR filter frequency response
filter by transfer function
convolve two vectors
return Hamming window coefficients
return Hanning window coefficients

Image Processing
colormap (map)
gray2ind (i, n)
image (img, zoom)
imagesc (img, zoom)
imread (file)
imshow (img, map)
imshow (i, n)
imshow (r, g, b)
imwrite (img, file)
ind2gray (img, map)
ind2rgb (img, map)
rgb2ind (r, g, b)
save a matrix to file

display value of var to screen

Polynomials
compan (p)
conv (a, b)
deconv (a, b)
poly (a)
polyderiv (p)
polyreduce (p)
polyval (p, x)
polyvalm (p, x)
roots (p)
residue (a, b)

companion matrix
convolution
deconvolve two vectors
create polynomial from a matrix
derivative of polynomial
integral of polynomial
value of polynomial at x
value of polynomial at x
polynomial roots
partial fraction expansion of ratio a/b

Statistics
corrcoef (x, y)
cov (x, y)
mean (a)
median (a)
std (a)
var (a)

correlation coefficient
covariance
mean value
median value
standard deviation
variance

Plotting Functions
set the current colormap
convert gray scale to Octave image
display an Octave image matrix
display scaled matrix as image
load an image file
display Octave image
display gray scale image
display RGB image
write images in various file formats
convert Octave image to gray scale
convert indexed image to RGB
convert RGB to Octave image

C-style Input and Output

fopen (name, mode)
fclose (file)
printf (fmt, ...)
fprintf (file, fmt, ...)
sprintf (fmt, ...)
scanf (fmt)
fscanf (file, fmt)
sscanf (str, fmt)
fgets (file, len)
fflush (file)
ftell (file)
frewind (file)
freport
fread (file, size, prec)
fwrite (file, size, prec)
feof (file)

disp (var)

open file name

close file
formatted output to stdout
formatted output to file
formatted output to string
formatted input from stdin
formatted input from file
formatted input from string
read len characters from file
flush pending output to file
return file pointer position
move file pointer to beginning
print a info for open files
read binary data files
write binary data files
determine if pointer is at EOF

plot (args)
plot3 (args)
line (args)
patch (args)
semilogx (args)
semilogy (args)
loglog (args)
bar (args)
stairs (x, y)
stem (x, y)
hist (y, x)
contour (x, y, z)
title (string)
axis (limits)
xlabel (string)
ylabel (string)
zlabel (string)
text (x, y, str)
legend (string)

2D plot with linear axes

3D plot with linear axes
2D or 3D line
2D patch
2D plot with logarithmic x-axis
2D plot with logarithmic y-axis
2D plot with logarithmic axes
plot bar charts
plot stairsteps
plot a stem graph
plot histograms
contour plot
set plot title
set axis ranges
set x-axis label
set y-axis label
set z-axis label
add text to a plot
set label in plot key

grid [on|off]

set grid state

hold [on|off]
ishold
mesh (x, y, z)
meshgrid (x, y)

set hold state

return 1 if hold is on, 0 otherwise
plot 3D surface
create mesh coordinate matrices

Edition 2.0 for Octave Version 3.0.0. Copyright 1996, 2007, John
W. Eaton ([email protected]). The author assumes no responsibility
for any errors on this card.
This card may be freely distributed under the terms of the GNU

A file may be referenced either by name or by the number

returned from fopen. Three files are preconnected when
Octave starts: stdin, stdout, and stderr.

General Public License.

Other Input and Output functions

Octave itself is free software; you are welcome to distribute copies

of it under the terms of the GNU General Public License. There is

save file var ...

load file

save variables in file

load variables from file

TEX Macros for this card by Roland Pesch ([email protected]),

originally for the GDB reference card

absolutely no warranty for Octave.