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

#### Matrices and Vectors

Creating vector or matrix in Octave is simple:octave:> A = [1 2 3; 4 5 6; 7 8 9]defines 3x3 matrix of integers.

A =

1 2 3

4 5 6

7 8 9

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)vector (number of columns is 1) of all ones:

allZeros =

0 0 0 0

0 0 0 0

octave:> allOnes = ones(3,1)or matrix with random values:

allOnes =

1

1

1

octave:> X = rand(3, 5)And finally getting a vector of values from 1 to N (row vector):

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

octave:> 1:Nand column (vector above transposed):

ans =

1 2 3 4 5 6 7 8 9 10

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:

Being a high level language Octave has control statementsIn 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.

*loops*

**if, switch,***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

*and you need to insert a column of*

**X***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

*(number of rows); then function*

**X***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

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

**randperm***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,

*corresponds to vector*

**1***(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 1

result = A(:, y);

__What just happened:__first we created an identity matrix

*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*

**A***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.

## No comments:

Post a Comment