**novyden**, and kindly contributed to R-bloggers)

I began using Octave for homework assignments from the online Machine Learning class. Having worked with languages like Python, Groovy and JavaScript I never expected a system designed for numerical computations to include such a complete and unique programming language. But it does and I can’t resist sharing some examples.

There are two important things one should know about Octave (or Matlab as Octave is usually portable to Matlab):

- Octave is a
**high level**language just like Python or Groovy - Using Octave without
**matrices or vectors**is like using Java without objects

Just these by themselves are worth a whole book on Octave but instead I go on with few cool examples (leaving the book for later :-).

#### Matrices and Vectors

Creating vector or matrix in Octave is simple:

octave:> A = [1 2 3; 4 5 6; 7 8 9]

A =1 2 3

4 5 6

7 8 9

defines 3×3 matrix of integers.

Use special functions to define special matrices, e.g. identity:

octave:> I = eye(3)

I =Diagonal Matrix

1 0 0

0 1 0

0 0 1

all zeros:

octave:> allZeros = zeros(2,4)

allZeros =0 0 0 0

0 0 0 0

vector (number of columns is 1) of all ones:

octave:> allOnes = ones(3,1)

allOnes =1

1

1

or matrix with random values:

octave:> X = rand(3, 5)

X =0.400801 0.091597 0.951333 0.063074 0.018309

0.690633 0.194094 0.417911 0.658953 0.624323

0.848887 0.696741 0.213559 0.363656 0.632738

And finally getting a vector of values from 1 to N (row vector):

octave:> 1:N

ans =1 2 3 4 5 6 7 8 9 10

and column (vector above transposed):

octave:> (1:N)’

ans =1

2

3

4

5

6

7

8

9

10

To stir things up a bit I make the following claim:

In Octave for any given problem there is higher than 50% chance that using matrices alone solves the problem with less code and more efficiently than when using loop and condition statements.

Being a high level language Octave has control statements * if, switch, *loops

*and*

**for***but using them in Octave is often your second choice. The reason are many matrix operators and functions Octave offers may accomplish a task without ever invoking a single control statement in a fraction of time.*

**while**Suppose you have a matrix * X* and you need to insert a column of

*in front. Then I just concatenate a vector of*

**1s***of proper size and*

**1s***:*

**X**X = [ ones(size(X, 1), 1), X ];

__What just happened:__ function *size *returned 1st dimension of array * X* (number of rows); then function

*ones*generated a vector (2d dimension is 1) of

*, and finally we concatenated column and*

**1s***X*. But this is only beginning.

#### Matrix magic

This example illustrates why and how things may work out better without control statements in Octave. Suppose I have a row vector (we may call it also an array but ultimately it is a single row matrix) of numbers from 1 to 10:

octave:> y = randperm(10)

y =4 3 1 8 6 10 9 2 7 5

octave:> y = repmat(y, 1, 10);

Function * randperm *returned a row vector containing random permutation of numbers 1 through 10. Then I used function

*to make vector*

**repmat***10 times its original length by repeating it 10 times (which results in 1 by 100 matrix*

**y***).*

**y**Now, to the problem we will solve. Let’s say each number from 1 to 10 corresponds to 10-dimensional vector of 0s and 1 with all of its elements set to 0 except the position of the number. Thus, * 1* corresponds to vector

*(1 0 0 0 0 0 0 0 0 0)*,

**corresponds to vector**

*2**(0 1 0 0 0 0 0 0 0 0)*and so on until

**that corresponds to**

*10**(0 0 0 0 0 0 0 0 0 1)*. Then given some vector

*like above (where each element is a number from 1 to 10) we want to produce series of vectors that correspond to elements in*

**y***.*

**y**If you never worked with Octave before then solution may amaze you, if you did then this might be your normal routine:

A = eye(10)

A =

Diagonal Matrix

1 0 0 0 0 0 0 0 0 0

0 1 0 0 0 0 0 0 0 0

0 0 1 0 0 0 0 0 0 0

0 0 0 1 0 0 0 0 0 0

0 0 0 0 1 0 0 0 0 0

0 0 0 0 0 1 0 0 0 0

0 0 0 0 0 0 1 0 0 0

0 0 0 0 0 0 0 1 0 0

0 0 0 0 0 0 0 0 1 0

0 0 0 0 0 0 0 0 0 1result = A(:, y);

__What just happened:__ first we created an identity matrix * A* of size 10 – note that it consists of exactly 10 vectors we are mapping to and each is in right column position. Now, we just plug our original vector y into column index of matrix A. This will extract elements from A: all for rows and precisely right columns. Thus

*gives us matrix which is 2nd column of*

**A(:, 2)***,*

**A***gives us matrix with columns of*

**A(:, 2:4)***from 2 to 4, same is accomplished with*

**A***, and*

**A(:, [2:4])***selects 1st, 4th and 9th columns of*

**A(:, [1 4 9])***. Finally, we can plug an arbitrary vector in column index – in our case vector*

**A***just what we need and*

**y***becomes 10 by 100 matrix where each column corresponds to element of*

**result***.*

**y**As unconventional as it may sound I keep thinking of this solution in terms of ranges when indexing arrays. Indexing array could be via an integer, range, or array of numbers. The latter is just a vector and that is all to it.

**leave a comment**for the author, please follow the link and comment on their blog:

**novyden**.

R-bloggers.com offers

**daily e-mail updates**about R news and tutorials on topics such as: Data science, Big Data, R jobs, visualization (ggplot2, Boxplots, maps, animation), programming (RStudio, Sweave, LaTeX, SQL, Eclipse, git, hadoop, Web Scraping) statistics (regression, PCA, time series, trading) and more...