Chuakz: Matrix Calculator

This was my first group assignment after officially entering the Informatics major at ITB. Our team called itself Chuakz, simply because the word was trending at the time.

That ordinary name ended up attached to a very important project for me. It was our introduction to the pace, collaboration, and technical expectations of Informatics coursework after two semesters of general engineering.

None of us had used Java before. We were learning a new language and programming style while also implementing linear-system solvers, determinants, inverses, interpolation, regression, bicubic splines, and file-based input and output.

The mathematics was already substantial, but the unfamiliar language made every feature more challenging. This was not a small exercise completed after learning Java. Learning Java was part of completing the exercise.

My main contributions were multiple linear regression, Cramer’s rule, cofactor determinants, input validation, file output, and integration work across the application.

I naturally enjoyed integration because it gave me a reason to understand what my teammates had built. Connecting the features into one usable program meant learning their assumptions, data formats, and mathematical logic instead of treating their modules as black boxes.

Multiple linear regression was my favorite part. I already found it fascinating that simple linear regression could be calculated by hand. This project generalized the same idea so a computer could work with several variables and a much larger system.

Understanding the normal-equation transformation was a little difficult, but I enjoyed mathematics at the time, so the difficulty felt rewarding. Seeing the program predict nitrous oxide concentration from humidity, pressure, and temperature made the abstraction feel complete.

Implementing determinant expansion through cofactors made recursion feel concrete. The definition translated naturally into code: choose an element, construct its smaller submatrix, and recursively calculate the next determinant.

It was elegant, but testing larger matrices took a painfully long time. The recursive tree grew rapidly, turning a mathematically beautiful implementation into an early lesson about computational cost.

I never liked solving matrices through row reduction by hand. The row swaps and elimination steps were tedious and easy to get wrong. Yet the same method that felt unpleasant on paper was fast and efficient for a computer, even if developing it correctly was harder.

Cramer’s rule created the opposite impression. It was elegant to describe, but repeatedly calculating determinants made it expensive. Seeing those approaches beside each other was eye-opening: two correct algorithms for the same problem can have dramatically different running times.

Parametric solutions were probably the hardest case because we had only recently learned how they worked. The program had to return relationships between variables instead of a neat list of final numbers.

Hilbert matrices were another difficult test because floating-point precision made seemingly simple calculations fragile. They reminded us that translating mathematics into software also means confronting the limits of numerical representation.

The bonus applied bicubic spline interpolation to image scaling. Seeing the same matrix operations produce a visibly resized image was phenomenal. It turned the project from a collection of terminal calculations into something we could immediately see.

Submitting everything was the most satisfying moment. We earned a score above 100 because we completed the bonus. More importantly, we had survived our first Informatics group project while still learning how quickly assignments moved and how early a team needed to manage its time.

This project taught me that mathematical notation does not become reliable software automatically. Every formula needs control flow, numerical decisions, validation, and careful handling of cases that look simple on paper.

Turning mathematics into code was hard, but satisfying when the output finally matched. That feeling became one of my first reference points for what engineering in Informatics could be.