radio/RealVector2.cpp

#include <windows.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include "RealVector.hpp"

void RealDebug(char *fmtstr, ...)
{
	char buf[1024];
	va_list args;

	va_start(args, fmtstr);
	vsprintf(buf, fmtstr, args);
	va_end(args);
	OutputDebugString(buf);

}

// -------------------------------------------------
// Assignments
// -------------------------------------------------
// = RealVector
RealVector& RealVector::operator=(const RealVector &src)
{
	uint32_t i;
	uint32_t j;
	uint32_t dj;

	checkSize(m_size, src.m_size);

	j = 0;
	dj = src.m_size > 1;
	if (src.isNegative())
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] = -src.m_pPtrReal[j];
			j += dj;
		}
	}
	else
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] = src.m_pPtrReal[j];
			j += dj;
		}
	}
	return *this;
}

// += RealVector
RealVector& RealVector::operator+=(const RealVector &src)
{
	uint32_t i;
	uint32_t j;
	uint32_t dj;

	checkSize(m_size, src.m_size);

	j = 0;
	dj = src.m_size > 1;
	if (src.isNegative())
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] -= src.m_pPtrReal[j];
			j += dj;
		}
	}
	else
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] += src.m_pPtrReal[j];
			j += dj;
		}
	}
	return *this;
}

// -= RealVector
RealVector& RealVector::operator-=(const RealVector &src)
{
	uint32_t i;
	uint32_t j;
	uint32_t dj;

	checkSize(m_size, src.m_size);

	j = 0;
	dj = src.m_size > 1;
	if (src.isNegative())
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] += src.m_pPtrReal[j];
			j += dj;
		}
	}
	else
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] -= src.m_pPtrReal[j];
			j += dj;
		}
	}
	return *this;
}

// *= RealVector
RealVector& RealVector::operator*=(const RealVector &src)
{
	uint32_t i;
	uint32_t j;
	uint32_t dj;

	checkSize(m_size, src.m_size);

	j = 0;
	dj = src.m_size > 1;
	if (src.isNegative())
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] *= -src.m_pPtrReal[j];
			j += dj;
		}
	}
	else
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] *= src.m_pPtrReal[j];
			j += dj;
		}
	}
	return *this;
}

// /= RealVector
RealVector& RealVector::operator/=(const RealVector &src)
{
	uint32_t i;
	uint32_t j;
	uint32_t dj;

	checkSize(m_size, src.m_size);

	j = 0;
	dj = src.m_size > 1;
	if (src.isNegative())
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] /= -src.m_pPtrReal[j];
			j += dj;
		}
	}
	else
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] /= src.m_pPtrReal[j];
			j += dj;
		}
	}
	return *this;
}

// = RealVector::OpBinary
RealVector& RealVector::operator=(const OpBinary &src)
{
	uint32_t i, j, k;
	uint32_t dj, dk;

	dj = src.a.m_size > 1;
	dk = src.b.m_size > 1;

	j = 0;
	k = 0;
	switch (src.op)
	{
		case OpBinary::ADD:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] = + src.a.m_pPtrReal[j] + src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] = - src.a.m_pPtrReal[j] - src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::SUB:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] = + src.a.m_pPtrReal[j] - src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else	
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] = - src.a.m_pPtrReal[j] + src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::MUL:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] = + src.a.m_pPtrReal[j] * src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] = - src.a.m_pPtrReal[j] * src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::DIV:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] = + src.a.m_pPtrReal[j] / src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] = - (src.a.m_pPtrReal[j] / src.b.m_pPtrReal[k]);
				j += dj;
				k += dk;
			}
		}
		break;

		default:
			break;
	}
	return *this;
}

// += RealVector::OpBinary
RealVector& RealVector::operator+=(const OpBinary &src)
{
	uint32_t i, j, k;
	uint32_t dj, dk;

	dj = src.a.m_size > 1;
	dk = src.b.m_size > 1;

	j = 0;
	k = 0;
	switch (src.op)
	{
		case OpBinary::ADD:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] += + src.a.m_pPtrReal[j] + src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] += - src.a.m_pPtrReal[j] - src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::SUB:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] += + src.a.m_pPtrReal[j] - src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else	
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] += - src.a.m_pPtrReal[j] + src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::MUL:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] += + src.a.m_pPtrReal[j] * src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] += - src.a.m_pPtrReal[j] * src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::DIV:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] += + src.a.m_pPtrReal[j] / src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] += - (src.a.m_pPtrReal[j] / src.b.m_pPtrReal[k]);
				j += dj;
				k += dk;
			}
		}
		break;

		default:
			break;
	}
	return *this;
}

// -= RealVector::OpBinary
RealVector& RealVector::operator-=(const OpBinary &src)
{
	uint32_t i, j, k;
	uint32_t dj, dk;

	dj = src.a.m_size > 1;
	dk = src.b.m_size > 1;

	j = 0;
	k = 0;
	switch (src.op)
	{
		case OpBinary::ADD:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] -= + src.a.m_pPtrReal[j] + src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] -= - src.a.m_pPtrReal[j] - src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::SUB:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] -= + src.a.m_pPtrReal[j] - src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else	
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] -= - src.a.m_pPtrReal[j] + src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::MUL:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] -= + src.a.m_pPtrReal[j] * src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] -= - src.a.m_pPtrReal[j] * src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::DIV:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] -= + src.a.m_pPtrReal[j] / src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] -= - (src.a.m_pPtrReal[j] / src.b.m_pPtrReal[k]);
				j += dj;
				k += dk;
			}
		}
		break;

		default:
			break;
	}
	return *this;
}

// *= RealVector::OpBinary
RealVector& RealVector::operator*=(const OpBinary &src)
{
	uint32_t i, j, k;
	uint32_t dj, dk;

	dj = src.a.m_size > 1;
	dk = src.b.m_size > 1;

	j = 0;
	k = 0;
	switch (src.op)
	{
		case OpBinary::ADD:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] *= + src.a.m_pPtrReal[j] + src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] *= - src.a.m_pPtrReal[j] - src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::SUB:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] *= + src.a.m_pPtrReal[j] - src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else	
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] *= - src.a.m_pPtrReal[j] + src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::MUL:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] *= + src.a.m_pPtrReal[j] * src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] *= - src.a.m_pPtrReal[j] * src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::DIV:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] *= + src.a.m_pPtrReal[j] / src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] *= - (src.a.m_pPtrReal[j] / src.b.m_pPtrReal[k]);
				j += dj;
				k += dk;
			}
		}
		break;

		default:
			break;
	}
	return *this;
}

// /= RealVector::OpBinary
RealVector& RealVector::operator/=(const OpBinary &src)
{
	uint32_t i, j, k;
	uint32_t dj, dk;

	dj = src.a.m_size > 1;
	dk = src.b.m_size > 1;

	j = 0;
	k = 0;
	switch (src.op)
	{
		case OpBinary::ADD:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] /= + src.a.m_pPtrReal[j] + src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] /= - src.a.m_pPtrReal[j] - src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::SUB:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] /= + src.a.m_pPtrReal[j] - src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else	
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] /= - src.a.m_pPtrReal[j] + src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::MUL:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] /= + src.a.m_pPtrReal[j] * src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] /= - src.a.m_pPtrReal[j] * src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		break;

		case OpBinary::DIV:
		if (!src.isNegative())
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] /= + src.a.m_pPtrReal[j] / src.b.m_pPtrReal[k];
				j += dj;
				k += dk;
			}
		}
		else
		{
			for (i=0; i < m_size; i++)
			{
				m_pPtrReal[i] /= - (src.a.m_pPtrReal[j] / src.b.m_pPtrReal[k]);
				j += dj;
				k += dk;
			}
		}
		break;

		default:
			break;
	}
	return *this;
}

// -------------------------------------------------
// Binary Operators
// -------------------------------------------------
// Returning RealVector::OpBinary
RealVector::OpBinary operator+(const RealVector &a, const RealVector &b)
{
	if (a.isNegative())
	{
		if (b.isNegative())
		{
			return -RealVector::OpBinary (a, b, RealVector::OpBinary::ADD);
		}
		else
		{
			return RealVector::OpBinary (b, a, RealVector::OpBinary::SUB);
		}
	}

	if (b.isNegative())
	{
		return RealVector::OpBinary (a, b, RealVector::OpBinary::SUB);
	}
	else
	{
		return RealVector::OpBinary (a, b, RealVector::OpBinary::ADD);
	}
}

RealVector::OpBinary operator-(const RealVector &a, const RealVector &b)
{
	if (a.isNegative())
	{
		if (b.isNegative())
		{
			return RealVector::OpBinary (b, a, RealVector::OpBinary::SUB);
		}
		else
		{
			return -RealVector::OpBinary (a, b, RealVector::OpBinary::ADD);
		}
	}

	if (b.isNegative())
	{
		return RealVector::OpBinary (a, b, RealVector::OpBinary::SUB);
	}
	else
	{
		return RealVector::OpBinary (a, b, RealVector::OpBinary::ADD);
	}
}

RealVector::OpBinary operator*(const RealVector &a, const RealVector &b)
{
	if (a.isNegative())
	{
		if (b.isNegative())
		{
			return RealVector::OpBinary (a, b, RealVector::OpBinary::MUL);
		}
		else
		{
			return -RealVector::OpBinary (a, b, RealVector::OpBinary::MUL);
		}
	}

	if (b.isNegative())
	{
		return -RealVector::OpBinary (a, b, RealVector::OpBinary::MUL);
	}
	else
	{
		return RealVector::OpBinary (a, b, RealVector::OpBinary::MUL);
	}
}

RealVector::OpBinary operator/(const RealVector &a, const RealVector &b)
{
	if (a.isNegative())
	{
		if (b.isNegative())
		{
			return RealVector::OpBinary (a, b, RealVector::OpBinary::DIV);
		}
		else
		{
			return -RealVector::OpBinary (a, b, RealVector::OpBinary::DIV);
		}
	}

	if (b.isNegative())
	{
		return -RealVector::OpBinary (a, b, RealVector::OpBinary::DIV);
	}
	else
	{
		return RealVector::OpBinary (a, b, RealVector::OpBinary::DIV);
	}
}