Program Listing for File Vector.cpp

↰ Return to documentation for file (src/LouLib/Math/Vector.cpp)

#include "Vector.hpp"
#include <utility>

namespace LouLib {
    namespace Math {

        Vector::Vector(int n){
            data.resize(n, 0);
        }

        Vector::Vector(std::initializer_list<double> vectorData) : data(vectorData) {}

        Vector::Vector(std::vector<double> vectorData) : data(std::move(vectorData)) {}

        Vector::Vector(const Vector& other) : data(other.data) {}

        double& Vector::operator[](int i) {
            if(i < 0 || i >= data.size()){
                throw std::invalid_argument("Index out of bounds");
            }
            return data[i];
        }

        const double& Vector::operator[](int i) const {
            if(i < 0 || i >= data.size()){
                throw std::invalid_argument("Index out of bounds");
            }
            return data[i];
        }

        int Vector::size() const {
            return (int) data.size();
        }

        double Vector::norm() {
            double sol = 0;
            for(int i = 0; i < size(); i++){
                sol += data[i] * data[i];
            }
            return std::sqrt(sol);
        }

        Vector Vector::normalize() {
            Vector result(size());
            double mag = norm();
            for(int i = 0; i < size(); i++){
                result[i] = data[i] / mag;
            }
            return result;
        }

        std::string Vector::toString() {
            std::string sol = "{";
            for(int i = 0; i < data.size(); i++){
                sol += std::to_string(data[i]);
                if(i != data.size()-1) sol += ", ";
            }
            sol += "}";
            return sol;
        }

        Vector operator+(const Vector &a, const Vector &b) {
            if(a.size() != b.size()){
                throw std::invalid_argument("Vectors must have the same size.");
            }
            Vector result(a.size());
            for (int i = 0; i < a.size(); i++) {
                result[i] = a[i] + b[i];
            }
            return result;
        }

        Vector operator-(const Vector &a, const Vector &b) {
            if(a.size() != b.size()){
                throw std::invalid_argument("Vectors must have the same size.");
            }
            Vector result(a.size());
            for (int i = 0; i < a.size(); i++) {
                result[i] = a[i] - b[i];
            }
            return result;
        }

        double operator*(const Vector &a, const Vector &b) {
            if(a.size() != b.size()){
                throw std::invalid_argument("Vectors must have the same size.");
            }
            double result = 0;
            for(int i = 0; i < a.size(); i++){
                result += a[i] * b[i];
            }
            return result;
        }

        Vector operator*(const double &a, const Vector &b) {
            Vector result(b.size());
            for(int i = 0; i < b.size(); i++){
                result[i] = b[i] * a;
            }
            return result;
        }

        Vector operator*(const Vector &a, const double &b) {
            Vector result(a.size());
            for(int i = 0; i < a.size(); i++){
                result[i] = a[i] * b;
            }
            return result;
        }

    } // Math
} // LouLib