options in function variables octave

The following octave code shows how to make functions take different paths depending on a user specified choice. It is a little template that comes in handy once in a while.

$cat options_in_function_variables_01.m
# Author : Kamaraju S. Kusumanchi
# Email  : kamaraju at gmail dot com
# Last modified : Tue Jun 15 06:45:15 EDT 2010
function [X] = options_in_function_variables_01(X, choice)

if (strcmp(choice, "square"))
 X = X*X;
elseif (strcmp(choice, "unity"))
 X = X*1;
elseif (strcmp(choice, "cube"))
 X = X*X*X;
else
 printf("choice = %s is not a valid option.\n", choice);
 error("please provide a correct choice");
endif
endfunction

To test it

$octave -qf
octave:1> options_in_function_variables_01(2.2, 'unity')
ans =  2.2000
octave:2> options_in_function_variables_01(2.2, 'square')
ans =  4.8400
octave:3> options_in_function_variables_01(2.2, 'cube')
ans =  10.648
octave:4> 10.648/4.84
ans =  2.2000
octave:5> 4.84/2.2
ans =  2.2000

passing functions as arguments in octave

It is possible to pass functions as arguments to another function in Octave. Consider the following sample code

$ls
cube.m  dynamic.m  script.m  square.m

$cat square.m
function [sq] = square(x)
sq = x**2;
endfunction

$cat cube.m
function [cu] = cube(x)
cu = x**3;
endfunction

$cat dynamic.m
function [ ret ] = dynamic (fh, x)
# fh is a function name passed as a string
# ex:-    b = dynamic("cube", a);
# fh can also be a handle
#         handle = @square;
#         b = dynamic(handle, a);
ret = feval(fh, x);
endfunction

$cat script.m
a=5.0

# bh = b obtained by using handle as arguments
handle=@square;
bh = dynamic( handle, a)

# bs = b obtained by using strings as arguments
bs = dynamic("square", a)

# ch = c obtained by using handle as arguments
handle=@cube;
ch = dynamic( handle, a)

# cs = c obtained by using strings as arguments
cs = dynamic("cube", a)

Run the script.m in octave

$octave3.2 -qf script.m

a =  5
bh =  25
bs =  25
ch =  125
cs =  125

Tested using Debian Lenny (stable), Octave 3.2.4

Further Reading:
1) The section on "Function handles, Inline Functions, and Anonymous Functions" in the octave manual http://www.gnu.org/software/octave/doc/interpreter/Function-Handles-Inline-Functions-and-Anonymous-Functions.html

2) http://rosettacode.org/wiki/Higher-order_functions explains how to do this kind of "calling functions from functions" in various programming languages

initializing multi dimensional arrays in octave

In octave, multi dimensional arrays can be initialized using the reshape function. As an example, consider the following script.

$cat multidimensional_array.m
1;
a = zeros(1, 24);
for i=1:24
  a(i) = i;
end
a
b = reshape(a, [4 3 2])

The output looks as follows

$octave -q
octave:1> multidimensional_array
a =

 Columns 1 through 16:

    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16

 Columns 17 through 24:

   17   18   19   20   21   22   23   24

b =

ans(:,:,1) =

    1    5    9
    2    6   10
    3    7   11
    4    8   12

ans(:,:,2) =

   13   17   21
   14   18   22
   15   19   23
   16   20   24



octave:2>

executing octave scripts

Using Octave 3.0.1, bash 4.1.5(1)-release on Debian Squeeze (stable)

$cat even_odd.m
# prevent Octave from thinking that this is a function file
clear;

function even_odd1(m)
# use bitand instead of mod to figure out if a number is odd or even
# if (mod(m, 2) == 1)
if (bitand(m,1))
 printf("%d is odd\n", m)
else
 printf("%d is even\n", m)
endif
endfunction

n = 25
even_odd1(n)
n = 30
even_odd1(n)

The above octave script can be run
1. Directly at the command line by doing

$octave -qf even_odd.m
n =  25
25 is odd
n =  30
30 is even

2. Inside Octave by doing

$octave -qf
octave:1> even_odd
n =  25
25 is odd
n =  30
30 is even
octave:2> n
n =  30

The advantage of first method is that no interaction is necessary. Useful for well tested scripts. The advantage of second method is that variables can be accessed even after the script is executed. Useful while debugging.

3. Source the script inside Octave

$octave -qf
octave:1> source("./even_odd.m")
n =  25
25 is odd
n =  30
30 is even

This approach comes in handy if the name of the script contains any special characters (ex:- '-' hyphen) or if the script has to be called by its relative path name.