# Tips and tricks

# C++

## Real matrix operations

This is a table of matrix operations commonly performed in Octave and their equivalents in C++ when using the octave libraries.

Operation | Octave | C++ |

add | `A+B` | `A+B` |

subtract | `A-B` | `A-B` |

matrix multiplication | `A*B` | `A*B` |

element multiplication | `A.*B` | `product(A,B) ` |

element division | `A./B` | `quotient(A,B) ` |

transpose* | `A'` | `A.transpose()` |

select element m,n of A** | `A(m,n)` | `A(m-1,n-1)` |

select row N of A** | `A(N,:)` | `A.row(N-1)` |

select column N of A** | `A(:,N)` | `A.column(N-1)` |

extract submatrix of A | `A(a:b,c:d)` | `A.extract(a-1,c-1,b-1,d-1)` |

absolute value of A | `abs(A)` | `A.abs()` |

comparison to scalar*** | `A>2` | `mx_el_gt(A,2)` |

`A<2` | `mx_el_lt(A,2)` | |

`A==2` | `mx_el_eq(A,2)` | |

`A~=2` | `mx_el_ne(A,2)` | |

`A>=2` | `mx_el_ge(A,2)` | |

`A<=2` | `mx_el_le(A,2)` | |

matrix of zeros | `A=zeros(m,n)` | `A.fill(0.0)` |

matrix of ones | `A=ones(m,n)` | `A.fill(1.0)` |

identity matrix | `eye(N)` | `identity_matrix(N,N)` |

inverse of A | `inv(A)` | `A.inverse()` |

pseudoinverse of A | `pinv(A)` | `A.pseudo_inverse()` |

diagonal elements of A | `diag(A)` | `A.diag()` |

column vector | `A(:)` | `ColumnVector(A.reshape (dim_vector(A.length())))` |

row vector | `A(:)'` | `RowVector(A.reshape (dim_vector(A.length())))` |

check for Inf or <a href="wiki.pl?NaN">NaN</a> | `any(~isfinite(A))` | `A.any_element_is_inf_or_nan()` |

stack two matrices vertically | `A=[B;C]` | `B.stack(C)` |

uniform random matrix | `rand(a,b)` | `octave_rand::distribution("uniform"); octave_rand::matrix(a,b)` |

normal random matrix | `randn(a,b)` | `octave_rand::distribution("normal"); octave_rand::matrix(a,b)` |

sum squares of columns | `sumsq(A)` | `A.sumsq()` |

sum along columns | `sum(A,1)` | `A.sum(0)` |

sum along rows | `sum(A,2)` | `A.sum(1)` |

product along columns | `prod(A,1)` | `A.prod(0)` |

product along rows | `prod(A,2)` | `A.prod(1)` |

cumsum along columns | `cumsum(A,1)` | `A.cumsum(0)` |

cumsum along rows | `cumsum(A,2)` | `A.cumsum(1)` |

cumproduct along columns | `cumprod(A,1)` | `A.cumprod(0)` |

cumproduct along rows | `cumprod(A,2)` | `A.cumprod(1)` |

number of rows | `size(A,1)` | `A.rows()` |

number of columns | `size(A,2)` | `A.cols()` |

Notes: *Transpose, addition, and multiplication operations also apply to RowVector, ComplexRowVector, ColumnVector, and ComplexColumnVector data types when the dimensions are in agreement. **The difference is due to the fact that arrays are zero-based in C++, but one-based in Octave. ***The names of Octave internal functions, such as mx_el_gt, are not documented and are subject to change. Functions such as mx_el_gt may eventually be available at both the scripting level and in C++ under more common names such as gt.

## Complex Matrix Operations

Operation | Octave | C++ |

conjugate tranpose | `A'` | `A.hermitian()` |

# General

## How to declare functions inside a test block

function experience %!test %! experience_design_mat %! experience_obs_eqs %! assert (experience_design_mat == pi); %! assert (experience_obs_eqs == exp(1)); %! %! endfunction % this is a trick. %! % now we can declare functions to be used by the test above. %! %! function a = experience_design_mat %! a = pi; %! endfunction %! %! function b = experience_obs_eqs %! b = exp(1); %! % endfunction: don't add it here. Let test() do it.

## A funny formatting trick with fprintf found by chance

Imagine that you want to create a text table with fprintf with 2 columns of 15 characters width and both right justified. How to do this thing?

That's easy:

If the variable Text is a cell array of strings (of length <15) with two columns and a certain number of rows, simply type for the kth row of Text

fprintf('%15.15s | %15.15s\n', Text{k,1}, Text{k,2});

The syntax '%<n>.<m>s' allocates '<n>' places to write chars and display the '<m>' first characters of the string to display.

Example:

octave:1> Text={'Hello','World'}; octave:2> fprintf('%15.15s | %15.15s\n', Text{1,1}, Text{1,2}) Hello | World

## Load Comma Separated Values (*.csv) files

A=textread("file.csv", "%d", "delimiter", ","); B=textread("file.csv", "%s", "delimiter", ","); inds = isnan(A); B(!inds) = num2cell(A(!inds))

This gets you a 1 column cell array. You can reshape it to the original size by using the ```
reshape</function>
```

`The next version of octave (3.6) implements the `

`CollectOutput`

switch as seen in example 8 here: http://www.mathworks.com/help/techdoc/ref/textscan.html

## Using Variable Strings in Octave Commands

For example, to plot data using a string variable as a legend:

Option 1 (simplest):

legend = "-1;My data;";
plot(x, y, legend);

Option 2 (to insert variables):

plot(x, y, sprintf("-1;%s;", dataName));

Option 3 (not as neat):

legend = 'my legend';
plot_command = ['plot(x,y,\';',legend,';\')'];
eval(plot_command);

These same tricks are useful for reading and writing data files with unique names, etc.

## Vectorizing Tricks=

You can easily fill a vector with an index:

for i=1:n, x(i) = i; end

x = [1:n];

This works for expressions on the index by wrapping the index in an expression:

for i=1:n, x(i) = sin(2*pi*i*f/r); end
x = sin(2*pi*[1:n]*f/r);

You can also work with other vectors this way:

for i=1:n, x(i) = sin(2*pi*y(i)*f/r); end

x = sin(2*pi*y*f/r);

Conditionals in the for loop are a little bit tricky. We need to create an index vector for the true condition, and another for the false condition, then calculate the two independently.

for i=1:n, if y(i)<1, x(i)=y(i); else x(i) = 2*y(i); endif

idx = y < 1;
x(idx) = y(idx);
x(!idx) = 2*y(!idx);

FIXME: add the following

- examples from matrices
- tricks with sort and cumsum (e.g., hist, lookup)
- counter-examples such as a tridiagonal solver
- sparse matrix tricks
- tricks relying on fortran indexing

### Other references

- MATLAB array manipulation tips and tricks by Peter Acklam: http://home.online.no/~pjacklam/matlab/doc/mtt/index.html
- The MathWorks: Code Vectorization Guide: http://www.mathworks.com/support/tech-notes/1100/1109.html