TVector.h

#pragma once
#include <cmath>
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#define MySetw 15


template <class T>
class TVector
{
	int size;
	T* val;

public:

	explicit TVector(int n);
	TVector();
	TVector(int n, T* p);
	TVector(const TVector<T>& vec);
	~TVector();

	TVector<T> operator +(const TVector<T>& vec);
	TVector<T> operator -(const TVector<T>& vec);
	TVector<T> operator *(const double scalar);
	TVector<T> operator /(const double scalar);
	TVector<T>& operator =(const TVector<T>& vec);
	TVector<T>& operator +=(const TVector<T>& vec);
	TVector<T>& operator -=(const TVector<T>& vec);
	T& operator [](const int index);
	T& operator [](const int index) const;
	TVector<T>& operator ++();
	TVector<T> operator ++(int);
	TVector<T>& operator --();
	TVector<T> operator --(int);

	bool operator ==(const TVector<T>& vec) const;
	bool operator !=(const TVector<T>& vec) const;

	double ScalarProduct(const TVector<T>& vec) const;
	TVector<T> CrossProduct(const TVector<T>& vec) const;
	double TripleProduct(const TVector<T>& vec2, const TVector<T>& vec3) const;

	void SetSize(unsigned int new_size);
	void SetVal(unsigned int index, const T);

	int GetSize();

	friend std::ostream& operator <<(std::ostream& os, const TVector<T>& vec)
	{
		int padding;
		try
		{
			padding = (MySetw - std::to_string(vec.val[0]).length()) / 2;
			for (int i = 0; i < padding; ++i)
			{
				os << " ";
				
			}
			os << vec.val[0];
			for (int i = 0; i < padding; ++i)
			{
				os << " ";
			}
		}
		catch (...)
		{
			throw std::exception("TVector std::ostream& operator << failure");
		}

		for (int i = 1; i < vec.size; i++)
		{
			try
			{
				padding = (MySetw - std::to_string(vec.val[i]).length()) / 2;
				for (int i = 0; i < padding; ++i)
				{
					os << " ";
					
				}
				os << vec.val[i];
				for (int i = 0; i < padding; ++i)
				{
					os << " ";
				}
			}
			catch (...)
			{
				throw std::exception("TVector std::ostream& operator << failure");
			}
		}

		return os;
	}

	friend std::istream& operator>>(std::istream& is, TVector<T>& vec)
	{
		// Skip leading newline
		if (is.peek() == '\n')
		{
			is.ignore();
		}


		// Read the input line
		std::string input;
		std::getline(is, input);
		std::istringstream inps(input);

		inps >> std::ws;

		//while (inps.peek() == '\n')
		//{
		//	inps.ignore();
		//	inps >> std::ws;
		//}

		// Skip opening parenthesis
		if (inps.peek() == '(')
		{
			inps.ignore();
		}

		// Read vector elements
		for (int i = 0; i < vec.size; i++)
		{
			try
			{
				if (!(inps >> vec.val[i]))
				{
					// Error handling: Failed to extract vector element
					is.setstate(std::ios::failbit);
					break;
				}
			}
			catch (...)
			{
				throw std::exception("TVector std::istream& operator>> failure.");
			}
		}

		// Skip space after elements
		if (inps.peek() == ' ')
		{
			inps.ignore();
		}

		// Skip closing parenthesis
		if (inps.peek() == ')')
		{
			inps.ignore();
		}

		// Check for failbit and handle errors
		if (is.fail())
		{
			// Uncomment the line below if you want to throw an exception for failbit
			throw std::exception("TVector std::istream& operator>> error: std::ios::failbit.");
		}

		// Clear any error flags and return the stream
		is.clear();
		return is;
	}
};

#include "TVector.h"

template <class T>
int TVector<T>::GetSize()
{
	return size;
}

template <class T>
void TVector<T>::SetSize(unsigned int new_size)
{
	if (size != new_size)
	{
		T* new_val;
		unsigned int breakpoint_size;

		if (new_size > size) { breakpoint_size = size; }
		else { breakpoint_size = new_size; }


		new_val = new T[new_size];
		if (new_val == nullptr) { throw std::exception("TVector.SetSize memory allocation failure."); }

		for (int i = 0; i < breakpoint_size; i++)
		{
			try
			{
				new_val[i] = val[i];
			}
			catch (...)
			{
				throw std::exception("TVector.SetSize assignment failure.");
			}
		}

		delete[] val;

		val = new_val;
		size = new_size;
	}
}

template <class T>
void TVector<T>::SetVal(unsigned int index, const T)
{
	try
	{
		val[index] = T;
	}
	catch (...)
	{
		throw std::exception("TVector assignment failure.");
	}
}

template <class T>
inline TVector<T>& TVector<T>::operator +=(const TVector<T>& vec)
{
	try
	{
		*this = *this + vec;
	}
	catch (...)
	{
		throw std::exception("TVector operator += failure.");
	}

	return *this;
}

template <class T>
inline TVector<T>& TVector<T>::operator -=(const TVector<T>& vec)
{
	try
	{
		*this = *this - vec;
	}
	catch (...)
	{
		throw std::exception("TVector operator -= failure.");
	}

	return *this;
}

template <class T>
inline bool TVector<T>::operator ==(const TVector<T>& vec) const
{
	bool flag_equal = 1;

	if (size != vec.size)
	{
		flag_equal = 0;
	}
	else
	{
		for (int i = 0; i < size; i++)
		{
			try
			{
				if (val[i] != vec.val[i])
				{
					flag_equal = 0;
					break;
				}
			}
			catch (...)
			{
				throw std::exception("TVector operator == failure. ");
			}
		}
	}

	return flag_equal;
}

template <class T>
inline bool TVector<T>::operator !=(const TVector<T>& vec) const
{
	bool flag_equal = 1;

	if (size != vec.size)
	{
		flag_equal = 0;
	}
	else
	{
		for (int i = 0; i < size; i++)
		{
			try
			{
				if (val[i] != vec.val[i])
				{
					flag_equal = 0;
					break;
				}
			}
			catch (...)
			{
				throw std::exception("TVector operator != failure. ");
			}
		}
	}

	return !(flag_equal);
}

template <class T>
inline double TVector<T>::ScalarProduct(const TVector<T>& vec) const
{
	double res = 0;

	try
	{
		if (size == vec.size)
		{
			for (int i = 0; i < size; i++)
			{
				try
				{
					res = res + (val[i] * vec.val[i]);
				}
				catch (...)
				{
					throw std::exception("TVector.ScalarProduct multiplication failure.");
				}
			}
		}
		else
		{
			throw std::exception("TVector::ScalarProduct failure: unequal vector size.");
		}
	}
	catch (...)
	{
		throw std::exception("TVector::ScalarProduct operator == failure.");
	}

	return res;
}

template <class T>
inline TVector<T> TVector<T>::CrossProduct(const TVector<T>& vec) const
{
	TVector res(size);


	if (size == 3 && vec.size == 3)
	{
		//Hardcoded formulas

		try
		{
			res.val[0] = val[1] * vec.val[2] - val[2] * vec.val[1];
			res.val[1] = val[2] * vec.val[0] - val[0] * vec.val[2];
			res.val[2] = val[0] * vec.val[1] - val[1] * vec.val[0];
		}
		catch (...)
		{
			throw std::exception("TVector::CrossProduct multiplication, substraction or memory access failure.");
		}
	}
	else
	{
		throw std::exception("TVector::CrossProduct if (size == 3 && vec.size == 3) not fulfilled.");
	}

	return res;
}

template <class T>
inline double TVector<T>::TripleProduct(const TVector<T>& vec1, const TVector<T>& vec2) const
{
	double res;

	if (vec1.size == 3 && vec2.size == 3 && size == 3)
	{
		try
		{
			res = (*this).ScalarProduct(vec1.CrossProduct(vec2));
		}
		catch (...)
		{
			throw std::exception("TVector::TripleProduct ScalarProduct, CrossProduct or memory access failure.");
		}
	}
	else
	{
		throw std::exception("TVector::TripleProduct if (vec1.size == 3 && vec2.size == 3 && size == 3) not fulfilled.");
		res = 0;
	}

	return res;
}

template <class T>
inline TVector<T>::TVector(int n)
{
	val = new T[n];
	if (val == nullptr) { throw std::exception("TVector::TVector(int n) memory allocation failure."); }
	size = n;
}

template <class T>
inline TVector<T>::TVector()
{
	val = new T[1];
	if (val == nullptr) { throw std::exception("TVector::TVector(int n) memory allocation failure."); }
	size = 1;
}

template <class T>
inline TVector<T>::TVector(int n, T* p)
{
	size = n;

	val = new T[n];
	if (val == nullptr) {
		throw std::exception("TVector::TVector(int n, T* p) memory allocation failure.");
	}

	for (int i = 0; i < n; i++)
	{
		try
		{
			val[i] = p[i];
		}
		catch (...)
		{
			throw std::exception("TVector::TVector(int n, T* p) assigment failure.");
		}
	}
}

template <class T>
inline TVector<T>::TVector(const TVector<T>& vec)
{
	size = vec.size;
	std::exception possible_exception("");

	val = new T[vec.size];
	if (val == nullptr) {
		throw std::exception("TVector::TVector(const TVector<T>& vec) memory allocation failure.");
	}

	for (int i = 0; i < size; i++)
	{
		try
		{
			val[i] = vec.val[i];
		}
		catch (...)
		{
			throw std::exception("TVector::TVector(const TVector<T>& vec) assigment failure.");
		}
	}
}

template <class T>
inline TVector<T>::~TVector()
{
	delete[] val;
	size = 0;
}

template <class T>
inline TVector<T>& TVector<T>::operator =(const TVector<T>& vec)
{
	if (this != &vec)
	{
		if (size != vec.size)
		{
			delete[] val;
			size = vec.size;
			val = new T[size];
			if (val == nullptr) {
				throw std::exception("TVector::operator = memory allocation failure.");
			}
		}

		for (int i = 0; i < size; i++)
		{
			try
			{
				val[i] = vec.val[i];
			}
			catch (...)
			{
				throw std::exception("TVector::operator = assigment failure.");
			}
		}
	}
	else
	{
		throw std::exception("TVector::operator =, if (this != &vec) not fulfilled.");
	}

	return *this;
}

template <class T>
inline TVector<T> TVector<T>::operator +(const TVector<T>& vec)
{
	TVector res(size);

	if (size == vec.size)
	{
		for (int i = 0; i < size; i++)
		{
			try
			{
				res[i] = val[i] + vec.val[i];
			}
			catch (...)
			{
				throw std::exception("TVector::operator + addition or assignment failure.");
			}
		}
	}
	else
	{
		throw std::exception("TVector::operator +, if (size == vec.size) not fulfilled.");
	}

	return res;
}

template <class T>
inline TVector<T> TVector<T>::operator -(const TVector<T>& vec)
{
	TVector res(size);

	if (size == vec.size)
	{
		for (int i = 0; i < size; i++)
		{
			try
			{
				res[i] = val[i] - vec.val[i];
			}
			catch (...)
			{
				throw std::exception("TVector::operator - substraction or assignment failure.");
			}
		}
	}
	else
	{
		throw std::exception("TVector::operator -, if (size == vec.size) not fulfilled.");
	}

	return res;
}

template <class T>
inline TVector<T> TVector<T>::operator *(const double scalar)
{
	TVector<T> res(size);

	for (int i = 0; i < size; i++)
	{
		try
		{
			res[i] = val[i] * scalar;
		}
		catch (...)
		{
			throw std::exception("TVector::operator *(const double scalar) multiplication or assignment failure.");
		}
	}

	return res;
}

template <class T>
inline TVector<T> TVector<T>::operator /(const double scalar)
{
	TVector<T> res(size);

	if (scalar != 0)
	{
		for (int i = 0; i < size; i++)
		{
			try
			{
				res[i] = val[i] / scalar;
			}
			catch (...)
			{
				throw std::exception("TVector::operator /(const double scalar) failure: division or assignment failure.");
				break;
			}
		}
	}
	else
	{
		throw std::exception("TVector::operator /(const double scalar) failure: division by zero.");
	}

	return res;
}

template <class T>
inline T& TVector<T>::operator [](const int index)
{
	if (abs(index) < size && index > -1)
	{
		return val[index];
	}
	else if (abs(index) < size && index < 0)
	{
		return val[size + index];
	}
	else if (abs(index) >= size)
	{
		throw std::exception("TVector::operator [](const int index) failure: abs(index) > size");
	}

	return val[0];
}

template <class T>
inline T& TVector<T>::operator [](const int index) const
{
	if (abs(index) < size && index > -1)
	{
		return val[index];
	}
	else if (abs(index) < size && index < 0)
	{
		return val[size + index];
	}
	else if (abs(index) > size)
	{
		throw std::exception("TVector::operator [](const int index) failure: abs(index) > size");
	}

	return val[0];
}

template <class T>
inline TVector<T>& TVector<T>::operator ++()
{
	for (int i = 0; i < size; i++)
	{
		try
		{
			val[i]++;
		}
		catch (...)
		{
			throw std::exception("TVector::operator ++ failure;");
		}
	}

	return *this;
}

template <class T>
inline TVector<T> TVector<T>::operator ++(int)
{
	TVector res(*this);

	for (int i = 0; i < size; i++)
	{
		try
		{
			val[i]++;
		}
		catch (...)
		{
			throw std::exception("TVector::operator ++(int) failure;");
		}
	}

	return res;
}

template <class T>
inline TVector<T>& TVector<T>::operator --()
{
	for (int i = 0; i < size; i++)
	{
		try
		{
			val[i]--;
		}
		catch (...)
		{
			throw std::exception("TVector::operator -- failure;");
		}
	}

	return *this;
}

template <class T>
inline TVector<T> TVector<T>::operator --(int)
{
	TVector res(*this);

	for (int i = 0; i < size; i++)
	{
		try
		{
			val[i]--;
		}
		catch (...)
		{
			throw std::exception("TVector::operator --(int) failure;");
		}
	}

	return res;
}