radio/RealVector.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);
	puts(buf);

}

// Class methods
// Standard constructor
RealVector::RealVector(uint32_t size, radio_float_t *real)
	: m_size(size)
	, m_real(0)
	, m_pBufReal(0)
	, m_pPtrReal(real)
{
	if (!real)
	{
		m_pBufReal = new radio_float_t[m_size];
		memset(m_pBufReal, 0, m_size*sizeof(radio_float_t));
		m_pPtrReal = m_pBufReal;
	}
}

// Copy constructor
RealVector::RealVector(const RealVector &src)
	: m_size(src.m_size)
	, m_real(0)
	, m_pBufReal(0)
	, m_pPtrReal(0)
{
	m_pBufReal = new radio_float_t[m_size];
	m_pPtrReal = m_pBufReal;

	*this = src;
}

// Slicing constructor
RealVector::RealVector(const RealVector &src, uint32_t from, uint32_t step, uint32_t to)
	: m_size(0)
	, m_real(src.m_real)
	, m_pBufReal(0)
	, m_pPtrReal(&src.m_pPtrReal[from])
{
	uint32_t i;

	for (i=from; i <= to; i+=step)
	{
		m_size++;
	}
}

// Unary resolver constructor (no data copy)
RealVector::RealVector(const RealVector &src, unary_t unary_modifier)
	: m_size(src.m_size)
	, m_real(src.m_real)
	, m_pBufReal(0)
	, m_pPtrReal(src.m_pPtrReal)
	, m_unary_modifier(unary_modifier)
{
}

// OpBinaryAdd resolver copy constructor
RealVector::RealVector(const OpBinary<Add> &src)
	: m_size(src.a.m_size)
	, m_real(0)
	, m_pBufReal(0)
	, m_pPtrReal(0)
{
	m_pBufReal = new radio_float_t[m_size];
	m_pPtrReal = m_pBufReal;

	*this = src;
}

// OpBinarySub resolver copy constructor
RealVector::RealVector(const OpBinary<Sub> &src)
	: m_size(src.a.m_size)
	, m_real(0)
	, m_pBufReal(0)
	, m_pPtrReal(0)
{
	m_pBufReal = new radio_float_t[m_size];
	m_pPtrReal = m_pBufReal;

	*this = src;
}

// OpBinaryMul resolver copy constructor
RealVector::RealVector(const OpBinary<Mul> &src)
	: m_size(src.a.m_size)
	, m_real(0)
	, m_pBufReal(0)
	, m_pPtrReal(0)
{
	m_pBufReal = new radio_float_t[m_size];
	m_pPtrReal = m_pBufReal;

	*this = src;
}

// OpBinaryDiv resolver copy constructor
RealVector::RealVector(const OpBinary<Div> &src)
	: m_size(src.a.m_size)
	, m_real(0)
	, m_pBufReal(0)
	, m_pPtrReal(0)
{
	m_pBufReal = new radio_float_t[m_size];
	m_pPtrReal = m_pBufReal;

	*this = src;
}

// Scalar constructor
RealVector::RealVector(radio_float_t real)
	: m_size(1)
	, m_real(real)
	, m_pBufReal(0)
	, m_pPtrReal(&m_real)
{
}

RealVector::~RealVector(void)
{
	if (m_pBufReal)
		delete(m_pBufReal);

	m_pBufReal = nullptr;
}

uint32_t RealVector::getSize() const
{
	return m_size;
}

radio_float_t RealVector::getValue() const
{
	return *m_pPtrReal;
}

RealVector RealVector::at(uint32_t const &i)
{
	return RealVector(*this, i, 1, i);
}

RealVector RealVector::slice(uint32_t from, uint32_t step, uint32_t to)
{
	return RealVector(*this, from, step, to);
}

void RealVector::print(char *pPrefix) const
{
	uint32_t i;

	RealDebug("%s:\n", pPrefix);
	for (i=0; i < m_size; i++)
	{
		RealDebug("%d: %.6f\n", i, m_pPtrReal[i]);
	}
}

bool RealVector::isNegative() const
{
	return m_unary_modifier.negative;
}

bool RealVector::isPositive() const
{
	return !m_unary_modifier.negative;
}

RealVector RealVector::operator-() const
{
	unary_t unary_modifier = m_unary_modifier;
	
	unary_modifier.negative = !unary_modifier.negative;
	return RealVector(*this, unary_modifier);
}

const RealVector& RealVector::operator+() const
{
	return *this;
}

RealVector::RealVector(const _RealVector &src)
	: m_size(src.m_size)
	, m_pBufReal(0)
	, m_pPtrReal(src.m_pPtrReal)
	, m_unary_modifier(src.m_unary_modifier)
{
}

_RealVector::_RealVector(const RealVector &src)
	: m_size(src.m_size)
	, m_real(src.m_real)
	, m_pBufReal(src.m_pBufReal)
	, m_pPtrReal(src.m_pPtrReal)
	, m_unary_modifier(src.m_unary_modifier)
{
}

_RealVector::_RealVector(const _RealVector &src, RealVector::unary_t unary_modifier)
	: m_size(src.m_size)
	, m_real(src.m_real)
	, m_pBufReal(src.m_pBufReal)
	, m_pPtrReal(src.m_pPtrReal)
	, m_unary_modifier(unary_modifier)
{
}

_RealVector _RealVector::operator-() const
{
	RealVector::unary_t unary_modifier = m_unary_modifier;
	
	unary_modifier.negative = !unary_modifier.negative;
	return _RealVector(*this, unary_modifier);
}

// -------------------------------------------------
// 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.isPositive())
	{
		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.isPositive())
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] += src.m_pPtrReal[j];
			j += dj;
		}
	}
	else
	{
		*this -= -src;
	}
	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.isPositive())
	{
		for (i=0; i < m_size; i++)
		{
			m_pPtrReal[i] -= src.m_pPtrReal[j];
			j += dj;
		}
	}
	else
	{
		*this += -src;
	}
	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.isPositive())
	{
		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.isPositive())
	{
		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::OpBinaryAdd
RealVector& RealVector::operator=(const OpBinary<Add> &src)
{
	uint32_t i, j, k;
	uint32_t dj, dk;

	if (src.a.isNegative() && src.b.isNegative())
	{
		*this = -(-src.a + -src.b);
		return *this;
	}
	if (src.a.isNegative())
	{
		*this = (src.b - -src.a);
		return *this;
	}
	if (src.b.isNegative())
	{
		*this = (src.a - -src.b);
		return *this;
	}

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

	j = 0;
	k = 0;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

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

	if (src.a.isNegative() && src.b.isNegative())
	{
		*this += -(-src.a + -src.b);
		return *this;
	}
	if (src.a.isNegative())
	{
		*this += (src.b - -src.a);
		return *this;
	}
	if (src.b.isNegative())
	{
		*this += (src.a - -src.b);
		return *this;
	}

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

	j = 0;
	k = 0;
	if (src.isPositive())
	{
		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
	{
		*this -= -src;
	}

	return *this;
}

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

	if (src.a.isNegative() && src.b.isNegative())
	{
		*this -= -(-src.a + -src.b);
		return *this;
	}
	if (src.a.isNegative())
	{
		*this -= (src.b - -src.a);
		return *this;
	}
	if (src.b.isNegative())
	{
		*this -= (src.a - -src.b);
		return *this;
	}

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

	j = 0;
	k = 0;
	if (src.isPositive())
	{
		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
	{
		*this += -src;
	}
	return *this;
}

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

	if (src.a.isNegative() && src.b.isNegative())
	{
		*this *= -(-src.a + -src.b);
		return *this;
	}
	if (src.a.isNegative())
	{
		*this *= (src.b - -src.a);
		return *this;
	}
	if (src.b.isNegative())
	{
		*this *= (src.a - -src.b);
		return *this;
	}

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

	j = 0;
	k = 0;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

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

	if (src.a.isNegative() && src.b.isNegative())
	{
		*this /= -(-src.a + -src.b);
		return *this;
	}
	if (src.a.isNegative())
	{
		*this /= (src.b - -src.a);
		return *this;
	}
	if (src.b.isNegative())
	{
		*this /= (src.a - -src.b);
		return *this;
	}

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

	j = 0;
	k = 0;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

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

	if (src.a.isNegative() && src.b.isNegative())
	{
		*this = (-src.b - -src.a);
		return *this;
	}
	if (src.a.isNegative())
	{
		*this = -(src.b + -src.a);
		return *this;
	}
	if (src.b.isNegative())
	{
		*this = (src.a + -src.b);
		return *this;
	}

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

	j = 0;
	k = 0;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

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

	if (src.a.isNegative() && src.b.isNegative())
	{
		*this += (-src.b - -src.a);
		return *this;
	}
	if (src.a.isNegative())
	{
		*this += -(src.b + -src.a);
		return *this;
	}
	if (src.b.isNegative())
	{
		*this += (src.a + -src.b);
		return *this;
	}

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

	j = 0;
	k = 0;
	if (src.isPositive())
	{
		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
	{
		*this -= -src;
	}
	return *this;
}

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

	if (src.a.isNegative() && src.b.isNegative())
	{
		*this -= (-src.b - -src.a);
		return *this;
	}
	if (src.a.isNegative())
	{
		*this -= -(src.b + -src.a);
		return *this;
	}
	if (src.b.isNegative())
	{
		*this -= (src.a + -src.b);
		return *this;
	}

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

	j = 0;
	k = 0;
	if (src.isPositive())
	{
		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
	{
		*this += -src;
	}
	return *this;
}

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

	if (src.a.isNegative() && src.b.isNegative())
	{
		*this *= (-src.b - -src.a);
		return *this;
	}
	if (src.a.isNegative())
	{
		*this *= -(src.b + -src.a);
		return *this;
	}
	if (src.b.isNegative())
	{
		*this *= (src.a + -src.b);
		return *this;
	}

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

	j = 0;
	k = 0;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;}

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

	if (src.a.isNegative() && src.b.isNegative())
	{
		*this /= (-src.b - -src.a);
		return *this;
	}
	if (src.a.isNegative())
	{
		*this /= -(src.b + -src.a);
		return *this;
	}
	if (src.b.isNegative())
	{
		*this /= (src.a + -src.b);
		return *this;
	}

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

	j = 0;
	k = 0;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

// = RealVector::OpBinaryMul
RealVector& RealVector::operator=(const OpBinary<Mul> &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;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

// += RealVector::OpBinaryMul
RealVector& RealVector::operator+=(const OpBinary<Mul> &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;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

// -= RealVector::OpBinaryMul
RealVector& RealVector::operator-=(const OpBinary<Mul> &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;
	if (src.isPositive())
	{
		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
	{
		*this += -src;
	}
	return *this;
}

// *= RealVector::OpBinaryMul
RealVector& RealVector::operator*=(const OpBinary<Mul> &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;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

// /= RealVector::OpBinaryMul
RealVector& RealVector::operator/=(const OpBinary<Mul> &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;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

// = RealVector::OpBinaryDiv
RealVector& RealVector::operator=(const OpBinary<Div> &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;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

// += RealVector::OpBinaryDiv
RealVector& RealVector::operator+=(const OpBinary<Div> &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;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

// -= RealVector::OpBinaryDiv
RealVector& RealVector::operator-=(const OpBinary<Div> &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;
	if (src.isPositive())
	{
		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
	{
		*this += -src;
	}
	return *this;
}

// *= RealVector::OpBinaryDiv
RealVector& RealVector::operator*=(const OpBinary<Div> &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;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

// /= RealVector::OpBinaryDiv
RealVector& RealVector::operator/=(const OpBinary<Div> &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;
	if (src.isPositive())
	{
		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;
		}
	}
	return *this;
}

// -------------------------------------------------
// Binary Operators
// -------------------------------------------------
// Returning RealVector::OpBinary
RealVector::OpBinary<RealVector::Add> operator+(const RealVector &a, const RealVector &b)
{
	return RealVector::OpBinary<RealVector::Add> (a, b);
}

//template <RealVector::OpType op>
RealVector::OpBinary<RealVector::Sub> operator-(const RealVector &a, const RealVector &b)
{
	return RealVector::OpBinary<RealVector::Sub> (a, b);
}

//template <RealVector::OpType op>
RealVector::OpBinary<RealVector::Mul> operator*(const RealVector &a, const RealVector &b)
{
	if (a.isNegative() != b.isNegative())
	{
		return -RealVector::OpBinary<RealVector::Mul> (a, b);
	}

	return RealVector::OpBinary<RealVector::Mul> (a, b);
}

//template <RealVector::OpType op>
RealVector::OpBinary<RealVector::Div> operator/(const RealVector &a, const RealVector &b)
{
	if (a.isNegative() != b.isNegative())
	{
		return -RealVector::OpBinary<RealVector::Div> (a, b);
	}

	return RealVector::OpBinary<RealVector::Div> (a, b);
}