Categorías

## Basis in a vector space

A vector space basis is the skeleton from which a vector space is built. It allows to decompose any signal into a linear combination of simple building blocks, namely, the basis vectors. The Fourier Transform is just a change of basis.

A vector basis is the linear combination of a set of vector that can write any vector of the space.

$w^{(k)} \leftarrow \text{basis}$

The canonical basis in $$\mathbb{R}^2$$ are:

$$e^{(0)} = [1, 0]^T \ \ e^{(1) } = [0,1]^T$$

Nevertheless, there are more basis for $$\mathbb{R}^2$$:

$$e^{(0)} = [1, 0]^T \ \ e^{(1) } = [1,1]^T$$

This former basis is not linearly independent as information of $$e^{(0)}$$ is inside $$e^{(1)}$$.

## Formal definition

H is a vector space.

W is a set of vectors from H such that $$W = \left\{ w^{(k)} \right\}$$

W is a basis of H if:

1. We can write $$\forall x \in H$$: $$x = \sum_{k=0}^{K-1} \alpha_k w^{(k)}, \ \ \alpha_k \in \mathbb{C}$$
2. $$\alpha_k$$ are unique, namely, there is linear independence in the basis, as a given point can only be expressed in a unique combination of the basis.

Orthogonal basis are those which inner product returns 0:

$$\left \langle w^{(k)}, w^{(n)} \right \rangle = 0, \ \ \text{for } k \neq n$$

In addition, if the self inner product of every basis element return 1, the basis are orthonormal.

## How to change the basis?

An element in the vector space can be represented with a new basis computing the projection of the current basis in the new basis. If $$x$$ is a vector element and is represented with the vector basis $$w^{(K)}$$ with the coefficients $$a_k$$, it can also be represented as a linear combination of the basis $$v^{(k)}$$ with the coefficients $$\beta_k$$. In a mathematical notation:

$x = \sum_{k=0}^{K-1} \alpha_k w^{(k)} = \sum_{k=0}^{K-1} \beta_k v^{(k)}$

If $$\left\{ v^{(k)} \right\}$$ is orthonormal, the new coefficients $$\beta_k$$ can be computed as a linear combination of the previous coefficients and the projection of the new basis over the original one:

$\beta_h = \left \langle v^{(h)}, x \right \rangle = \left \langle v^{(h)}, \sum_{k=0}^{K-1} \alpha_k w^{(k)} \right \rangle = \sum_{k=0}^{K-1} \alpha_k \left\langle v^{(h)}, w^{(k)} \right \rangle$

This operation can also be represented in a matrix form as follows:

$\beta_h = \begin{bmatrix} c_{00} & c_{01} & \cdots & c_{0\left(K-1 \right )}\\ & & \vdots & \\ c_{\left(K-1 \right )0} & c_{\left(K-1 \right )01} & \cdots & c_{\left(K-1 \right )\left(K-1 \right )} \end{bmatrix}\begin{bmatrix} \alpha_0 \\ \vdots \\ \alpha_{K-1} \end{bmatrix}$

This operation is widely used in algebra. A well-known example of a change of basis could be the Discrete Fourier Transform (DFT).

Categorías

## Inner product in vector space

The inner product is an operation that measures the similarity between vectors.  In a general way, the inner product could be defined as an operation of 2 operands, which are elements of a vector space. The result is a scalar in the set of the complex numbers:

$\left \langle \cdot, \cdot \right \rangle : V \times V \rightarrow \mathbb{C}$

## Formal properties

For $$x, y, z \in V$$ and $$\alpha \in \mathbb{C}$$, the inner product must fulfill the following rules:

To be distributive to vector addition:

$$\left \langle x+y, z \right \rangle = \left \langle x, z \right \rangle + \left \langle y, z \right \rangle$$

Conmutative with conjugate (applies when vectors are complex):

$$\left \langle x,y \right \rangle = \left \langle y, x \right \rangle^*$$

Distributive respect scalar multiplication:

$$\left \langle \alpha x, y \right \rangle = \alpha^* \left \langle x, u \right \rangle$$

$$\left \langle x, \alpha y \right \rangle = \alpha \left \langle x, u \right \rangle$$

The self inner product must be necessarily a real number:

$$\left \langle x, x \right \rangle \geq 0$$

The self inner product can be zero only when the element is the null element:

$$\left \langle x,x \right \rangle = 0 \Leftrightarrow x = 0$$

## Inner product in $$\mathbb{R}^2$$

The inner product in $$\mathbb{R}^2$$ is defined as follows:

$$\left \langle x, y \right \rangle = x_0 y_0 + x_1 y_1$$

In self inner product represents the squared norm of the vector:

$$\left \langle x, x \right \rangle = x^2_0 + y^2_0 = \left \| x \right \|^2$$

## Inner product in finite length signals

In this case, the inner product is defined as:

$\left \langle x ,y \right \rangle = \sum_{n= 0}^{N-1} x^*[n] y[n]$

Categorías

## Properties of vector spaces

Vector spaces must meet the following rules:
$$x + y = y + x$$

$$(x+y)+z = x + (y + z)$$

Scalar multiplication to be distributive with respect to vector addition:
$$\alpha\left(x + y \right) = \alpha x + \alpha y$$

Scalar multiplication to be distributive with respect to vector the addition of field scalars:
$$\left( \alpha + \beta \right) x = \alpha x + \beta y$$

Scalar multiplication to be associative:
$$\alpha\left(\beta x \right) = \left(\alpha \beta \right) x$$

It must exist a null element:
$$\exists 0 \in V \ \ | \ \ x + 0 = 0 + x = x$$

It must exist an inverse element for every element in the vector space:
$$\forall x \in V \exists (-x)\ \ | \ \ x + (-x) = 0$$

Categorías

## Energy and power of a signal

$E_x = \sum_{n=-\infty}^{+\infty} \left| x\left[ n \right] \right|^2$
$P_x = \lim_{N\to\infty} \frac{1}{2N + 1} \sum_{n = -N}^{N} \left| x[n] \right|^2$

Categorías

## The uvm_object class

The uvm_object class is the base class for all UVM classes. From it, all the rest of classes are extended. It provides basic functionalities such as print, compare, copy and similar methods.

This class can be used when defining reusable parts of a sequence items. For example, in a packet like uvm_sequence_item, we could define a uvm_object extended object for defining the header. This would be:

class packet_header extends uvm_object;

rand bit [2:0] len;

uvm_field_int(len, UVM_DEFAULT)
uvm_object_utils_end

super.new(name);
endfunction : new

endclass : packet_header

This packet_header could be included in a packet class for conforming the uvm_sequence_item (the transaction) which will compose the sequences:

class simple_packet extends uvm_sequence_item;

uvm_object_utils_begin(simple_packet)
uvm_field_object(header, UVM_DEFAULT)
uvm_object_utils_end

function new (string name = "simple_packet");
super.new(name);
endfunction : new

endclass : packet

Categorías

## Pseudo-random number generator with Fibonacci sequence

$s_k = (k\cdot A) \bmod B$

$$s_k$$ is the pseudo-random number and $$A$$ and $$B$$ are prime numbers. $$k$$ is in the range $$[0,B-1]$$. If $$k$$ is greater than $$B-1$$, the results will be repeat as $$B$$ is the period of the sequence.
For example, $$A = 7$$ and $$B = 17$$. This sequence written in MATLAB could be:

A = 7;
B = 17;
n = [];

t = 0:B;
for i=0:B
n = [n mod(i*A,B)];
end

stem(t,n);

Categorías

## Cordic in MATLAB

Let’s z be a 2D point in the space as $$z = x + jy$$, if we want to rotate this point a given angle $$\theta$$, we get the following expressions:
$e^{j\theta} \cdot z = \left(\cos{\theta} + j \sin{\theta}\right)\left(x+jy\right) \\ = x\cos{\theta}-y\sin{\theta} + j \left(y \cos{\theta} + x \sin{\theta} \right) \\ = x’ + j y’$

Then, for a generic point, the rotation can be expressed as an equation system, where $$x’$$ and $$y’$$ are the new coordinates, $$\theta$$ is the rotation angle and $$x$$ and $$y$$ are the original coordinates:
$\begin{bmatrix} x’\\ y’ \end{bmatrix}= \begin{bmatrix} \cos{\theta} & -\sin{\theta}\\ \sin{\theta} & \cos{\theta} \end{bmatrix}\begin{bmatrix} x\\ y \end{bmatrix}$

This rotation can be coded in MATLAB as:

%% Function to rotate vector
function v = rotate(P, theta)
rot = [cos(theta) -sin(theta);
sin(theta) cos(theta)];
v = rot*P;
end


A possible implementation of the cordic algorithm could be:

%% Clear all previous values
clear all;

%% Define vectors
A = [2;-3];
O = [0;0];

%% Define accuracy
error_limit = 0.01;

%% Initialize variables
start_angle = pi/2; % 90º
current_angle = start_angle;
acc_angle = 0;

A_rotated = A;
steps = 0;

% Second quadrant (90º - 180º)
if(A_rotated(1) < 0 && A_rotated(2) > 0)
A_rotated = rotate(A_rotated, -pi/2);
acc_angle = pi/2;
% Third quadrant (180º - 270º)
elseif(A_rotated(1) < 0 && A_rotated(2) < 0)
A_rotated = rotate(A_rotated, -pi);
acc_angle = pi;
% Forth quadrant (270º - 360º)
elseif(A_rotated(1) > 0 && A_rotated(2) < 0)
A_rotated = rotate(A_rotated, -3*pi/2);
acc_angle = 3*pi/2;
end

%% Compute angle
% Keep rotating while error is too high
while(abs(A_rotated(2)) > error_limit)
% Represent current vector
quiver(0, 0,A_rotated(1), A_rotated(2));
% Keep previous vectors
hold on;
% Decrease angle rotation
current_angle = current_angle/2;
% (For debugging purposes)
current_angle_deg = current_angle*180/pi;
% Save current error
error = A_rotated(2);
% If y coordinate is still positive
if(error > 0)
% Rotate again conterclockwise
A_rotated = rotate(A_rotated, -1*current_angle);
% Accumulate rotated angle
acc_angle = acc_angle + current_angle;
% If y coordinate is negative
else
% Rotate vector clockwise
A_rotated = rotate(A_rotated, current_angle);
% Substract current angle to the accumulator because we have
% overcome the actual angle value
acc_angle = acc_angle - current_angle;
end

% (For debugging purposes)
acc_angle_deg = acc_angle*180/pi;
% Increase step counter
steps = steps + 1;
end

% Print angle, hypotenuse length and number of steps needed to compute
fprintf('Angle = %f\nHypotenuse = %f\nNumber of steps: %d\n', acc_angle*180/pi, A_rotated(1), steps);

%% Function to rotate vector
function v = rotate(P, theta)
rot = [cos(theta) -sin(theta);
sin(theta) cos(theta)];
v = rot*P;
end



I have coded an interactive applet to illustrate the algorithm. It has been done using the p5.js library. The error limit has been set to $$0.5$$.

Categorías

## Install Quartus in Ubuntu 16.04

1. Open http://dl.altera.com/?edition=lite
4. Extract Quartus installer.
5. Run setup.sh: ./setup.sh
6. Select desired devices.
7. For launching modelsim, install libxft2 32 bit version library: sudo apt install libxft2:i386. Then execute ./vsim in the path intelFPGA_lite/17.1/modelsim_ase/linuxaloem/
Categorías

Categorías

## Rounding in C

#define round(x) x >= 0.0 ? (int)(x + 0.5) : ((x - (double)(int)x) >= -0.5 ? (int)x : (int)(x - 0.5))

Example:

#include <stdio.h>

#define round(x) x >= 0.0 ? (int)(x + 0.5) : ((x - (double)(int)x) >= -0.5 ? (int)x : (int)(x - 0.5))

void main(void){
float f1 = 3.14, f2 = 6.5, f3 = 7.99;
int r1, r2, r3;
r1 = round(f1);
r2 = round(f2);
r3 = round(f3);

printf("r1 = %d\nr2 = %d\nr3 = %d\n", r1, r2, r3);
}


The console output is:

r1 = 3
r2 = 7
r3 = 8