From 73633535288711de4850b9d9eec6326eb5de06c0 Mon Sep 17 00:00:00 2001
From: Siddarth-Suresh <65844402+Siddarth-Suresh@users.noreply.github.com>
Date: Thu, 24 Apr 2025 11:02:23 -0400
Subject: Template files for vectors to override arithmetic operations

---
 inc/vec.h  |  44 ++++++++++++++++++++++++
 src/vec.cc | 113 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 157 insertions(+)
 create mode 100644 inc/vec.h
 create mode 100644 src/vec.cc

diff --git a/inc/vec.h b/inc/vec.h
new file mode 100644
index 0000000..68482d5
--- /dev/null
+++ b/inc/vec.h
@@ -0,0 +1,44 @@
+// vec.h
+#ifndef VEC_H
+#define VEC_H
+
+#include <iostream>
+#include <vector>
+#include <stdexcept>
+
+template<typename T>
+class Vec {
+private:
+    std::vector<T> data;
+
+public:
+    Vec() = default;
+    Vec(const std::vector<T>& values) : data(values) {}
+
+    // Vector-Vector Operations
+    Vec<T> operator+(const Vec<T>& other) const;
+    Vec<T> operator-(const Vec<T>& other) const;
+    Vec<T> operator*(const Vec<T>& other) const;
+    Vec<T> operator/(const Vec<T>& other) const;
+    Vec<T> operator%(const Vec<T>& other) const;
+
+    // Vector-Scalar Operations
+    Vec<T> operator+(T scalar) const;
+    Vec<T> operator-(T scalar) const;
+    Vec<T> operator*(T scalar) const;
+    Vec<T> operator/(T scalar) const;
+    Vec<T> operator%(T scalar) const;
+
+    // Utility
+    void print() const;
+    size_t size() const { return data.size(); }
+
+    // Friend scalar-vector operations
+    friend Vec<T> operator+(T scalar, const Vec<T>& vec) { return vec + scalar; }
+    friend Vec<T> operator-(T scalar, const Vec<T>& vec);
+    friend Vec<T> operator*(T scalar, const Vec<T>& vec) { return vec * scalar; }
+    friend Vec<T> operator/(T scalar, const Vec<T>& vec);
+    friend Vec<T> operator%(T scalar, const Vec<T>& vec);
+};
+
+#endif
diff --git a/src/vec.cc b/src/vec.cc
new file mode 100644
index 0000000..e3e0a6c
--- /dev/null
+++ b/src/vec.cc
@@ -0,0 +1,113 @@
+#include "vec.h"
+
+template<typename T>
+Vec<T> Vec<T>::operator+(const Vec<T>& other) const {
+    if (data.size() != other.data.size()) throw std::invalid_argument("Size mismatch");
+    Vec<T> result;
+    for (size_t i = 0; i < data.size(); ++i)
+        result.data.push_back(data[i] + other.data[i]);
+    return result;
+}
+
+template<typename T>
+Vec<T> Vec<T>::operator-(const Vec<T>& other) const {
+    if (data.size() != other.data.size()) throw std::invalid_argument("Size mismatch");
+    Vec<T> result;
+    for (size_t i = 0; i < data.size(); ++i)
+        result.data.push_back(data[i] - other.data[i]);
+    return result;
+}
+
+template<typename T>
+Vec<T> Vec<T>::operator*(const Vec<T>& other) const {
+    if (data.size() != other.data.size()) throw std::invalid_argument("Size mismatch");
+    Vec<T> result;
+    for (size_t i = 0; i < data.size(); ++i)
+        result.data.push_back(data[i] * other.data[i]);
+    return result;
+}
+
+template<typename T>
+Vec<T> Vec<T>::operator/(const Vec<T>& other) const {
+    if (data.size() != other.data.size()) throw std::invalid_argument("Size mismatch");
+    Vec<T> result;
+    for (size_t i = 0; i < data.size(); ++i)
+        result.data.push_back(other.data[i] == 0 ? 0 : data[i] / other.data[i]);
+    return result;
+}
+
+template<typename T>
+Vec<T> Vec<T>::operator%(const Vec<T>& other) const {
+    if (data.size() != other.data.size()) throw std::invalid_argument("Size mismatch");
+    Vec<T> result;
+    for (size_t i = 0; i < data.size(); ++i)
+        result.data.push_back(other.data[i] == 0 ? 0 : data[i] % other.data[i]);
+    return result;
+}
+
+// Scalar versions
+template<typename T>
+Vec<T> Vec<T>::operator+(T scalar) const {
+    Vec<T> result;
+    for (const auto& val : data) result.data.push_back(val + scalar);
+    return result;
+}
+
+template<typename T>
+Vec<T> Vec<T>::operator-(T scalar) const {
+    Vec<T> result;
+    for (const auto& val : data) result.data.push_back(val - scalar);
+    return result;
+}
+
+template<typename T>
+Vec<T> Vec<T>::operator*(T scalar) const {
+    Vec<T> result;
+    for (const auto& val : data) result.data.push_back(val * scalar);
+    return result;
+}
+
+template<typename T>
+Vec<T> Vec<T>::operator/(T scalar) const {
+    Vec<T> result;
+    for (const auto& val : data) result.data.push_back(scalar == 0 ? 0 : val / scalar);
+    return result;
+}
+
+template<typename T>
+Vec<T> Vec<T>::operator%(T scalar) const {
+    Vec<T> result;
+    for (const auto& val : data) result.data.push_back(scalar == 0 ? 0 : val % scalar);
+    return result;
+}
+
+// Scalar - Vector versions
+template<typename T>
+Vec<T> operator-(T scalar, const Vec<T>& vec) {
+    Vec<T> result;
+    for (size_t i = 0; i < vec.size(); ++i)
+        result = result + (scalar - vec.data[i]);
+    return result;
+}
+
+template<typename T>
+Vec<T> operator/(T scalar, const Vec<T>& vec) {
+    Vec<T> result;
+    for (auto val : vec.data)
+        result = result + (val == 0 ? 0 : scalar / val);
+    return result;
+}
+
+template<typename T>
+Vec<T> operator%(T scalar, const Vec<T>& vec) {
+    Vec<T> result;
+    for (auto val : vec.data)
+        result = result + (val == 0 ? 0 : scalar % val);
+    return result;
+}
+
+template<typename T>
+void Vec<T>::print() const {
+    for (auto val : data) std::cout << val << " ";
+    std::cout << std::endl;
+}
-- 
cgit v1.2.3