BGN2/bgn2/src/Bipoint.cpp

#include "Bipoint.hpp"

CurveBipoint::CurveBipoint()
{
	curvepoint_fp_setneutral(point[0]);
	curvepoint_fp_setneutral(point[1]);
}

TwistBipoint::TwistBipoint()
{
	twistpoint_fp2_setneutral(point[0]);
	twistpoint_fp2_setneutral(point[1]);
}

CurveBipoint::CurveBipoint(curvepoint_fp_t p1, curvepoint_fp_t p2)
{
	curvepoint_fp_set(point[0], p1);
	curvepoint_fp_set(point[1], p2);
}

TwistBipoint::TwistBipoint(twistpoint_fp2_t p1, twistpoint_fp2_t p2)
{
	twistpoint_fp2_set(point[0], p1);
	twistpoint_fp2_set(point[1], p2);
}

curvepoint_fp_t& CurveBipoint::operator[](int n)
{
	return point[n];
}

twistpoint_fp2_t& TwistBipoint::operator[](int n)
{
	return point[n];
}

const curvepoint_fp_t& CurveBipoint::operator[](int n) const
{
	return point[n];
}

const twistpoint_fp2_t& TwistBipoint::operator[](int n) const
{
	return point[n];
}

CurveBipoint CurveBipoint::operator+(const CurveBipoint& b) const
{
	CurveBipoint retval;

	curvepoint_fp_add_vartime(retval[0], point[0], b.point[0]);
	curvepoint_fp_add_vartime(retval[1], point[1], b.point[1]);

	return retval;
}

TwistBipoint TwistBipoint::operator+(const TwistBipoint& b) const
{
	TwistBipoint retval;

	twistpoint_fp2_add_vartime(retval[0], point[0], b.point[0]);
	twistpoint_fp2_add_vartime(retval[1], point[1], b.point[1]);

	return retval;
}

CurveBipoint CurveBipoint::operator*(const Scalar& exp) const
{
	CurveBipoint retval;

	exp.mult(retval[0], point[0]);
	exp.mult(retval[1], point[1]);

	return retval;
}

TwistBipoint TwistBipoint::operator*(const Scalar& exp) const
{
	TwistBipoint retval;

	exp.mult(retval[0], point[0]);
	exp.mult(retval[1], point[1]);

	return retval;
}

bool CurveBipoint::operator==(const CurveBipoint& b) const
{
	curvepoint_fp_t affine_point0, affine_point1, affine_b0, affine_b1;

	curvepoint_fp_set(affine_point0, point[0]);
	curvepoint_fp_set(affine_point1, point[1]);
	curvepoint_fp_set(affine_b0, b[0]);
	curvepoint_fp_set(affine_b1, b[1]);

	curvepoint_fp_makeaffine(affine_point0);
	curvepoint_fp_makeaffine(affine_point1);
	curvepoint_fp_makeaffine(affine_b0);
	curvepoint_fp_makeaffine(affine_b1);

	bool retval;

	retval =           fpe_iseq(affine_point0->m_x, affine_b0->m_x);
	retval = retval && fpe_iseq(affine_point0->m_y, affine_b0->m_y); 
	retval = retval && fpe_iseq(affine_point1->m_x, affine_b1->m_x);
	retval = retval && fpe_iseq(affine_point1->m_y, affine_b1->m_y);

	return retval;
}

bool TwistBipoint::operator==(const TwistBipoint& b) const
{
	twistpoint_fp2_t affine_point0, affine_point1, affine_b0, affine_b1;

	twistpoint_fp2_set(affine_point0, point[0]);
	twistpoint_fp2_set(affine_point1, point[1]);
	twistpoint_fp2_set(affine_b0, b[0]);
	twistpoint_fp2_set(affine_b1, b[1]);

	twistpoint_fp2_makeaffine(affine_point0);
	twistpoint_fp2_makeaffine(affine_point1);
	twistpoint_fp2_makeaffine(affine_b0);
	twistpoint_fp2_makeaffine(affine_b1);

	bool retval;

	retval =           fp2e_iseq(affine_point0->m_x, affine_b0->m_x);
	retval = retval && fp2e_iseq(affine_point0->m_y, affine_b0->m_y); 
	retval = retval && fp2e_iseq(affine_point1->m_x, affine_b1->m_x);
	retval = retval && fp2e_iseq(affine_point1->m_y, affine_b1->m_y);

	return retval;
}

bool CurveBipoint::operator!=(const CurveBipoint& b) const
{
	return !(*this == b);
}

bool TwistBipoint::operator!=(const TwistBipoint& b) const
{
	return !(*this == b);
}

CurveBipoint CurveBipoint::mult_by_2() const
{
	CurveBipoint retval;

	curvepoint_fp_double(retval[0], point[0]);
	curvepoint_fp_double(retval[1], point[1]);

	return retval;
}

TwistBipoint TwistBipoint::mult_by_2() const
{
	TwistBipoint retval;

	twistpoint_fp2_double(retval[0], point[0]);
	twistpoint_fp2_double(retval[1], point[1]);

	return retval;
}

void CurveBipoint::make_affine()
{
	if (!(fpe_isone(point[0]->m_z)))
		curvepoint_fp_makeaffine(point[0]);
	if (!(fpe_isone(point[1]->m_z)))
		curvepoint_fp_makeaffine(point[1]);
}

void TwistBipoint::make_affine()
{
	if (!(fp2e_isone(point[0]->m_z)))
		twistpoint_fp2_makeaffine(point[0]);
	if (!(fp2e_isone(point[1]->m_z)))
		twistpoint_fp2_makeaffine(point[1]);
}

std::ostream& operator<<(std::ostream& os, const CurveBipoint& output)
{
	os << "{[";
	for (int i = 0; i < 2; i++)
	{
		os << Fpe(output[i]->m_x) << ", " << Fpe(output[i]->m_y) << ", " << Fpe(output[i]->m_z);
		if (i < 1)
			os << "], [";
	}
	os << "]}";

	return os;
}

std::ostream& operator<<(std::ostream& os, const TwistBipoint& output)
{
	os << "{[";
	for (int i = 0; i < 2; i++)
	{
		os << Fp2e(output[i]->m_x) << ", " << Fp2e(output[i]->m_y) << ", " << Fp2e(output[i]->m_z);
		if (i < 1)
			os << "], [";
	}
	os << "]}";

	return os;
}

size_t CurveBipointHash::operator()(const CurveBipoint& x) const
{
	size_t retval = 0;
	CurveBipoint affine_x = x;
	std::hash<double> hasher;
	
	affine_x.make_affine();

	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 12; j++)
		{
			retval ^= hasher(affine_x[i]->m_x->v[j]);
			retval ^= hasher(affine_x[i]->m_y->v[j]);
		}
	}

	return retval;
}

size_t TwistBipointHash::operator()(const TwistBipoint& x) const
{
	size_t retval = 0;
	TwistBipoint affine_x = x;
	std::hash<double> hasher;
	
	affine_x.make_affine();

	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 24; j++)
		{
			retval ^= hasher(affine_x[i]->m_x->v[j]);
			retval ^= hasher(affine_x[i]->m_y->v[j]);
		}
	}

	return retval;
}