Exercises¶

Use the button below to open a template in Compiler Explorer with the Eigen library included. You can use this template to complete the exercises below.

Open solution in Compiler Explorer

Basic Matrix and Vector operations¶

1. Vector Creation and Access

• Create a 5-element vector using Eigen and initialize it with values 1 through 5.

• Print the vector’s elements and demonstrate how to access individual elements.

2. Matrix Initialization

• Create a 3×3 matrix with all elements set to zero.

• Initialize a 2×4 matrix with specific values of your choice.

• Print both matrices to verify their contents.

3. Basic Math Functions

• Create a vector with values ranging from -5 to 5.

• Apply the absolute value, square root (for positive elements), and exponential functions.

• Calculate the sum, mean, minimum, and maximum values of the vector.

4. Coefficient-wise Operations

• Create two vectors of the same length.

• Perform element-wise multiplication, division, and power operations.

• Calculate the dot product and compare with element-wise multiplication.

5. Matrix Operations

• Create two 3×3 matrices with different values.

• Perform and print the results of addition, subtraction, and element-wise multiplication.

• Calculate and print the matrix product of the two matrices.

6. Vector-Matrix Operations

• Create a 3×3 matrix and a 3-element vector.

• Multiply the matrix by the vector and explain the result.

• Experiment with different ways to perform the multiplication.

7. Special Matrix Operations

• Create a 4×4 matrix and calculate its determinant, inverse, and transpose.

• Verify that A × A⁻¹ equals the identity matrix (within numerical precision).

• Explore how to check if a matrix is singular and handle potential errors.

Advanced Matrix operations¶

8. Block Operations

• Create a 4×4 matrix with sequential numbers (1-16).

• Extract the 2×2 block in the top-left corner.

• Extract the 2×2 block in the bottom-right corner.

• Replace the bottom-left 2×2 block with a new 2×2 matrix.

9. Row and Column Operations

• Create a 3×4 matrix with random values.

• Extract the second row and third column.

• Replace the first row with new values.

• Swap two columns of your choice.

10. Resizing and Reshaping

• Create a 2×3 matrix and then resize it to a 3×2 matrix.

• Create a 6-element vector and reshape it into a 2×3 matrix.

• Discuss what happens to the elements during these operations.

11. Concatenation

• Create two 2×2 matrices.

• Horizontally concatenate them to form a 2×4 matrix.

• Vertically concatenate them to form a 4×2 matrix.

• Create and demonstrate a function that can concatenate matrices of compatible dimensions.

12. Advanced Slicing

• Create a 5×5 matrix with sequential values.

• Extract non-contiguous rows and columns (e.g., rows 1, 3, 4 and columns 0, 2).

• Extract a diagonal or anti-diagonal of the matrix.

• Create a tiled pattern by repeating a smaller matrix.

13. Linear Algebra Operations

• Create a system of linear equations represented as Ax = b.

• Solve the system using Eigen’s solver capabilities.

• Verify your solution by substituting it back into the original equations.

14. Eigenvalues and Eigenvectors

• Create a symmetric 3×3 matrix.

• Calculate its eigenvalues and eigenvectors.

• Verify that Av = λv for each eigenvalue-eigenvector pair.

Practical Applications¶

15. Image Processing Basics

• Represent a grayscale image as an Eigen matrix.

• Implement basic operations like brightness adjustment and contrast enhancement.

• Apply simple filters (e.g., blur) using matrix operations.

Img::ImageGd image;

std::cout << "Loading image..." << std::endl;

if (!Img::load("images/half-moon-986269.png", image))
{
    std::cout << "Error loading image" << std::endl;
    return 1;
}

MatrixXd matrix = image.as_matrix();

Img::ImageGd copyToImage(const Eigen::MatrixXd &mat)
{
    ImageGd image;
    image.resize(mat.rows(), mat.cols());
    for (int i = 0; i < mat.rows(); i++)
        for (int j = 0; j < mat.cols(); j++)
            image(i, j) = mat(i, j);

    return image;
}

if (!Img::save("output.png", copyToImage(matrix)))
{
    std::cout << "Error saving image" << std::endl;
    return 1;
}

Eigen::MatrixXd createGaussianKernel(int size, double sigma)
{
    if (size % 2 == 0)
    {
        size++; // Make sure kernel size is odd
    }

    Eigen::MatrixXd kernel(size, size);
    int center = size / 2;
    double sum = 0.0;

    // Fill the kernel with Gaussian values
    for (int y = 0; y < size; y++)
    {
        for (int x = 0; x < size; x++)
        {
            int dx = x - center;
            int dy = y - center;
            float exponent = -(dx * dx + dy * dy) / (2 * sigma * sigma);
            kernel(y, x) = std::exp(exponent) / (2 * std::numbers::pi * sigma * sigma);
            sum += kernel(y, x);
        }
    }

    // Normalize the kernel so its sum equals 1
    kernel /= sum;

    return kernel;
}