I use R with Python a lot, Octave is the chosen language in Coursera course: Machine Learning by Stanford University.

So this article will only cover necessary concept to finish this Machine Learning course.

# Index

In Octave, matrix and vector are indexed from 1, which differs from many other languages.

# Output

One line not ending with a semicolon will print the result to output, with semicolon with suppress that output.

Or use `disp(i);` or `sprintf(i)`

strcmp, strmatch

# Cell-array

## Acess

``````ca = cell(2,1); % create cell array
ca{1} = 'abc'; % assign to first element
ca{2} = 'def'; % assign to second element
ca{1}; % access first element
``````

# Range

`1:10` will create a 1x10 matrix or say 10-element vector with numbers from 1 to 10. `1:2:10` will create vector with each other numbers from 1 to 10, i.e. `[1 3 5 7 9]`. The middle 2 is the specified step.

# Matrix, Vector

## Assignment

``````% assign a matrix to A:
A = [1 2; 3 4; 5 6]
A =
1   2
3   4
5   6

% assign to second column
>> A(:,2) = [10 11 12]
% space, comma or semicolon doesn't matter here
>> A(:,2) = [10, 11, 12]
>> A(:,2) = [10; 11; 12]
``````

## Access

``````% access A at first row and second column.
>> A(1,2)
ans = 2

% access second row, here colon refers to all columns
>> A(2,:)
ans =
3   4

% access second column
>> A(:,2)
ans =
2
4
6

a(2)       # result is a scalar
a(1:2)     # result is a row vector
a([1; 2])  # result is a column vector

a = [1, 2; 3, 4]
all of the following expressions are equivalent and select the first row of the matrix.

a(1, [1, 2])  # row 1, columns 1 and 2
a(1, 1:2)     # row 1, columns in range 1-2
a(1, :)       # row 1, all columns

a(1:end/2)        # first half of a => [1, 2]
a(end + 1) = 5;   # append element
a(end) = [];      # delete element
a(1:2:end)        # odd elements of a => [1, 3]
a(2:2:end)        # even elements of a => [2, 4]
a(end:-1:1)       # reversal of a => [4, 3, 2 , 1]
``````

## Fill

``````>> A = ones(2, 3) # ones or zeros
A =
1   1   1
1   1   1

>> rand(2, 3)
ans =
0.47210   0.10022   0.35182
0.69316   0.71345   0.71179
``````

## Concatenate

``````>> B = [20 21; 22 23; 24 25]
>> C = [A B] % concatenate A B horizontally
ans =
1   2   20   21
3   4   22   23
5   6   24   25

>> D = [A; B] % concatenate A B vertically
ans =
1   2
3   4
5   6
20  21
22  23
24  25
``````

## Transpose

``````>> A' % transpose
ans =
1   3   5
2   4   6
``````

## Max, Min

``````>> max(magic(4)) % return every column's max
ans =
16  14  15  13

>> max(magic(4), [], 2) % return every row's max
ans =
16
11
12
15

>> [val, ind] = max(magic(4)) % retuns every column's max and their index in corresponding column
val =
16  14  15  13
ind =
1   4   4   1

>> max(max(A)); % max element in matrix
>> A(:) % convert matrix into one column
ans =
1
3
5
2
4
6
>> max(A(:)) % max element in matrix
ans =
6
``````

## Sum

``````>> sum(A) % sum of column
>> sum(A, 2) % sum of row
``````

## Sum of diagonals in a square matrix

``````>> M = magic(4);
>> sum(sum(M.*eye(4))) % sum of diagonal top left to bottom right
ans = 34
>> sum(sum(M.* flipud(eye(4) ))) % sum of diagonal bottom left to top right
ans = 34
``````

## Flip

``````>> flipud(A) \$ flip matrix upside down
ans =
5   6
3   4
1   2
``````

## Matrix select

``````A(A==2)
``````

## Reshape

``````>> reshape(A, 2, 3)
ans =
1   5   4
3   2   6
``````

# Functions & control statements

Functions are saved in files with the file-ending .m for MATLAB.

``````function y = function_name(x1, ...
x2) % x2 is optional
if ~exist('x2', 'var') || isempty(x2)
x2 = 1;
end
y = x1 + x2;
% y is the return value
% x1 is a parameter
% is also possible to return multiple values
function [y1, y2] = function_name(x1)
y1 = x1^2
y2 = x1^3

>> for i=1:10
>>      disp(i)
>> end;

>> i = 1;
>> while (i ~= 10)
>>      disp(i);
>>      i = i+1;
>> endwhile;

% i = 10
>> if (i == 10)
>>      sprintf('yes')
>> else
>>      sprintf('no')
>> endif
ans = yes
``````

## Anonymous function

``````@(x1, x2) another_func(x1, x2) % anonymous function, just like Python lambda
``````

# Logic operations

not equal `~=`

logical AND `&&`

logical OR `||`

logical XOR `xor(1,0)`

Reference:

https://gist.github.com/obstschale/7320846

http://folk.ntnu.no/joern/itgk/refcard-a4.pdf