#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);

}

// Methods
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(RealVector &src, uint32_t from, uint32_t step, uint32_t to)
: m_size(0)
, m_pBufReal(0)
, m_pPtrReal(&src.m_pPtrReal[from])
{
	uint32_t i;

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

// Negative resolver copy constructor
RealVector::RealVector(const RealVectorNegative &src)
: m_size(src.m_size)
, m_real(src.m_real)
, m_pBufReal(0)
, m_pPtrReal(src.m_pPtrReal)
{
	*this = src;
}

// OpBinaryAdd resolver copy constructor
RealVector::RealVector(const OpBinaryAdd &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;
}

// OpBinaryAdd::Negative resolver copy constructor
RealVector::RealVector(const OpBinaryAdd::Negative &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 OpBinarySub &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 OpBinaryMul &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::Negative resolver copy constructor
RealVector::RealVector(const OpBinaryMul::Negative &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 OpBinaryDiv &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::Negative resolver copy constructor
RealVector::RealVector(const OpBinaryDiv::Negative &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);
}

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]);
	}
}

RealVectorNegative RealVector::operator-() const
{
	return RealVectorNegative(*this);
}

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

// -------------------------------------------------
// 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;
	for (i=0; i < m_size; i++)
	{
		m_pPtrReal[i] = src.m_pPtrReal[j];
		j += dj;
	}
	return *this;
}

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

	checkSize(m_size, src.m_size);

	j = 0;
	dj = src.m_size > 1;
	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;
	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;
	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;
	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;
	for (i=0; i < m_size; i++)
	{
		m_pPtrReal[i] /= src.m_pPtrReal[j];
		j += dj;
	}
	return *this;
}

// += RealVector::Negative
RealVector& RealVector::operator+=(const RealVectorNegative &src)
{
	*this -= -src;

	return *this;
}

// -= RealVector::Negative
RealVector& RealVector::operator-=(const RealVectorNegative &src)
{
	*this += -src;

	return *this;
}

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

	checkSize(m_size, src.m_size);

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

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

	checkSize(m_size, src.m_size);

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

// = RealVector::OpBinaryAdd
RealVector& RealVector::operator=(const OpBinaryAdd &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;
	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 OpBinaryAdd &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;
	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 OpBinaryAdd &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;
	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 OpBinaryAdd &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;
	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 OpBinaryAdd &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;
	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::Negative
RealVector& RealVector::operator=(const OpBinaryAdd::Negative &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;
	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::Negative
RealVector& RealVector::operator+=(const OpBinaryAdd::Negative &src)
{
	*this -= -src;

	return *this;
}

// -= RealVector::OpBinaryAdd::Negative
RealVector& RealVector::operator-=(const OpBinaryAdd::Negative &src)
{
	*this += -src;

	return *this;
}

// *= RealVector::OpBinaryAdd::Negative
RealVector& RealVector::operator*=(const OpBinaryAdd::Negative &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;
	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::Negative
RealVector& RealVector::operator/=(const OpBinaryAdd::Negative &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;
	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 OpBinarySub &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;
	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 OpBinarySub &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;
	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 OpBinarySub &src)
{
	*this += OpBinarySub(src.b, src.a);
	return *this;
}

// *= RealVector::OpBinarySub
RealVector& RealVector::operator*=(const OpBinarySub &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;
	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 OpBinarySub &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;
	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 OpBinaryMul &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;
	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 OpBinaryMul &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;
	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 OpBinaryMul &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;
	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 OpBinaryMul &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;
	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 OpBinaryMul &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;
	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::Negative
RealVector& RealVector::operator=(const OpBinaryMul::Negative &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;
	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::Negative
RealVector& RealVector::operator+=(const OpBinaryMul::Negative &src)
{
	*this -= -src;

	return *this;
}

// -= RealVector::OpBinaryMul::Negative
RealVector& RealVector::operator-=(const OpBinaryMul::Negative &src)
{
	*this += -src;

	return *this;
}

// *= RealVector::OpBinaryMul::Negative
RealVector& RealVector::operator*=(const OpBinaryMul::Negative &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;
	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::Negative
RealVector& RealVector::operator/=(const OpBinaryMul::Negative &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;
	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 OpBinaryDiv &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;
	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 OpBinaryDiv &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;
	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 OpBinaryDiv &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;
	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 OpBinaryDiv &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;
	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 OpBinaryDiv &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;
	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::Negative
RealVector& RealVector::operator=(const OpBinaryDiv::Negative &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;
	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::Negative
RealVector& RealVector::operator+=(const OpBinaryDiv::Negative &src)
{
	*this -= -src;

	return *this;
}

// -= RealVector::OpBinaryDiv::Negative
RealVector& RealVector::operator-=(const OpBinaryDiv::Negative &src)
{
	*this += -src;

	return *this;
}

// *= RealVector::OpBinaryDiv::Negative
RealVector& RealVector::operator*=(const OpBinaryDiv::Negative &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;
	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::Negative
RealVector& RealVector::operator/=(const OpBinaryDiv::Negative &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;
	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::OpBinaryAdd operator+(const RealVector &a, const RealVector &b)
{
	return RealVector::OpBinaryAdd (a, b);
}
#if 0
RealVector::OpBinarySub operator+(const RealVectorNegative &a, const RealVector &b)
{
	return RealVector::OpBinarySub (b, -a);
}

RealVector::OpBinarySub operator+(const RealVector &a, const RealVectorNegative &b)
{
	return RealVector::OpBinarySub (a, -b);
}

RealVector::OpBinaryAdd::Negative operator+(const RealVectorNegative &a, const RealVectorNegative &b)
{
	return -RealVector::OpBinaryAdd (-a, -b);
}
#endif
RealVector::OpBinarySub operator-(const RealVector &a, const RealVector &b)
{
	return RealVector::OpBinarySub (a, b);
}

RealVector::OpBinaryAdd::Negative operator-(const RealVectorNegative &a, const RealVector &b)
{
	return -RealVector::OpBinaryAdd (-a, b);
}

RealVector::OpBinaryAdd operator-(const RealVector &a, const RealVectorNegative &b)
{
	return RealVector::OpBinaryAdd (a, -b);
}

RealVector::OpBinarySub operator-(const RealVectorNegative &a, const RealVectorNegative &b)
{
	return RealVector::OpBinarySub (-b, -a);
}

RealVector::OpBinaryMul operator*(const RealVector &a, const RealVector &b)
{
	return RealVector::OpBinaryMul (a, b);
}

RealVector::OpBinaryMul::Negative operator*(const RealVectorNegative &a, const RealVector &b)
{
	return -RealVector::OpBinaryMul (-a, b);
}

RealVector::OpBinaryMul::Negative operator*(const RealVector &a, const RealVectorNegative &b)
{
	return -RealVector::OpBinaryMul (a, -b);
}

RealVector::OpBinaryMul operator*(const RealVectorNegative &a, const RealVectorNegative &b)
{
	return RealVector::OpBinaryMul (-a, -b);
}

RealVector::OpBinaryDiv operator/(const RealVector &a, const RealVector &b)
{
	return RealVector::OpBinaryDiv (a, b);
}

RealVector::OpBinaryDiv::Negative operator/(const RealVectorNegative &a, const RealVector &b)
{
	return -RealVector::OpBinaryDiv (-a, b);
}

RealVector::OpBinaryDiv::Negative operator/(const RealVector &a, const RealVectorNegative &b)
{
	return -RealVector::OpBinaryDiv (a, -b);
}

RealVector::OpBinaryDiv operator/(const RealVectorNegative &a, const RealVectorNegative &b)
{
	return RealVector::OpBinaryDiv (-a, -b);
}