/**
* Normalization ensures that any projective coordinate is 1, and therefore that the x, y
* coordinates reflect those of the equivalent point in an affine coordinate system. Where more
* than one point is to be normalized, this method will generally be more efficient than
* normalizing each point separately. An (optional) z-scaling factor can be applied; effectively
* each z coordinate is scaled by this value prior to normalization (but only one
* actual multiplication is needed).
*
* @param points
* An array of points that will be updated in place with their normalized versions,
* where necessary
* @param off
* The start of the range of points to normalize
* @param len
* The length of the range of points to normalize
* @param iso
* The (optional) z-scaling factor - can be null
*/
public virtual void NormalizeAll(ECPoint[] points, int off, int len, ECFieldElement iso)
{
CheckPoints(points, off, len);
switch (this.CoordinateSystem)
{
case ECCurve.COORD_AFFINE:
case ECCurve.COORD_LAMBDA_AFFINE:
{
if (iso != null)
{
throw new ArgumentException("not valid for affine coordinates", "iso");
}
return;
}
}
/*
* Figure out which of the points actually need to be normalized
*/
ECFieldElement[] zs = new ECFieldElement[len];
int[] indices = new int[len];
int count = 0;
for (int i = 0; i < len; ++i)
{
ECPoint p = points[off + i];
if (null != p && (iso != null || !p.IsNormalized()))
{
zs[count] = p.GetZCoord(0);
indices[count++] = off + i;
}
}
if (count == 0)
{
return;
}
ECAlgorithms.MontgomeryTrick(zs, 0, count, iso);
for (int j = 0; j < count; ++j)
{
int index = indices[j];
points[index] = points[index].Normalize(zs[j]);
}
}
public override ECPoint ImportPoint(ECPoint p)
{
if (this != p.Curve && this.CoordinateSystem == 2 && !p.IsInfinity)
{
switch (p.Curve.CoordinateSystem)
{
case 2:
case 3:
case 4:
return(new FpPoint(this, this.FromBigInteger(p.RawXCoord.ToBigInteger()), this.FromBigInteger(p.RawYCoord.ToBigInteger()), new ECFieldElement[]
{
this.FromBigInteger(p.GetZCoord(0).ToBigInteger())
}, p.IsCompressed));
}
}
return(base.ImportPoint(p));
}
public override ECPoint ImportPoint(ECPoint p)
{
if (this != p.Curve && this.CoordinateSystem == COORD_JACOBIAN && !p.IsInfinity)
{
switch (p.Curve.CoordinateSystem)
{
case COORD_JACOBIAN:
case COORD_JACOBIAN_CHUDNOVSKY:
case COORD_JACOBIAN_MODIFIED:
return(new FpPoint(this,
FromBigInteger(p.RawXCoord.ToBigInteger()),
FromBigInteger(p.RawYCoord.ToBigInteger()),
new ECFieldElement[] { FromBigInteger(p.GetZCoord(0).ToBigInteger()) }));
default:
break;
}
}
return(base.ImportPoint(p));
}
public virtual void NormalizeAll(ECPoint[] points, int off, int len, ECFieldElement iso)
{
this.CheckPoints(points, off, len);
int coordinateSystem = this.CoordinateSystem;
if (coordinateSystem == 0 || coordinateSystem == 5)
{
if (iso != null)
{
throw new ArgumentException("not valid for affine coordinates", "iso");
}
return;
}
else
{
ECFieldElement[] array = new ECFieldElement[len];
int[] array2 = new int[len];
int num = 0;
for (int i = 0; i < len; i++)
{
ECPoint eCPoint = points[off + i];
if (eCPoint != null && (iso != null || !eCPoint.IsNormalized()))
{
array[num] = eCPoint.GetZCoord(0);
array2[num++] = off + i;
}
}
if (num == 0)
{
return;
}
ECAlgorithms.MontgomeryTrick(array, 0, num, iso);
for (int j = 0; j < num; j++)
{
int num2 = array2[j];
points[num2] = points[num2].Normalize(array[j]);
}
return;
}
}
/**
* Normalization ensures that any projective coordinate is 1, and therefore that the x, y
* coordinates reflect those of the equivalent point in an affine coordinate system. Where more
* than one point is to be normalized, this method will generally be more efficient than
* normalizing each point separately.
*
* @param points
* An array of points that will be updated in place with their normalized versions,
* where necessary
*/
public virtual void NormalizeAll(ECPoint[] points)
{
CheckPoints(points);
if (this.CoordinateSystem == ECCurve.COORD_AFFINE)
{
return;
}
/*
* Figure out which of the points actually need to be normalized
*/
ECFieldElement[] zs = new ECFieldElement[points.Length];
int[] indices = new int[points.Length];
int count = 0;
for (int i = 0; i < points.Length; ++i)
{
ECPoint p = points[i];
if (null != p && !p.IsNormalized())
{
zs[count] = p.GetZCoord(0);
indices[count++] = i;
}
}
if (count == 0)
{
return;
}
ECAlgorithms.MontgomeryTrick(zs, 0, count);
for (int j = 0; j < count; ++j)
{
int index = indices[j];
points[index] = points[index].Normalize(zs[j]);
}
}
public virtual void NormalizeAll(ECPoint[] points, int off, int len, ECFieldElement iso)
{
this.CheckPoints(points, off, len);
switch (this.CoordinateSystem)
{
case 0:
case 5:
if (iso != null)
{
throw new ArgumentException("not valid for affine coordinates", "iso");
}
return;
}
ECFieldElement[] zs = new ECFieldElement[len];
int[] numArray = new int[len];
int index = 0;
for (int i = 0; i < len; i++)
{
ECPoint point = points[off + i];
if ((point != null) && ((iso != null) || !point.IsNormalized()))
{
zs[index] = point.GetZCoord(0);
numArray[index++] = off + i;
}
}
if (index != 0)
{
ECAlgorithms.MontgomeryTrick(zs, 0, index, iso);
for (int j = 0; j < index; j++)
{
int num5 = numArray[j];
points[num5] = points[num5].Normalize(zs[j]);
}
}
}
public override ECPoint ImportPoint(ECPoint p)
{
if (this != p.Curve && this.CoordinateSystem == COORD_JACOBIAN && !p.IsInfinity)
{
switch (p.Curve.CoordinateSystem)
{
case COORD_JACOBIAN:
case COORD_JACOBIAN_CHUDNOVSKY:
case COORD_JACOBIAN_MODIFIED:
return new FpPoint(this,
FromBigInteger(p.RawXCoord.ToBigInteger()),
FromBigInteger(p.RawYCoord.ToBigInteger()),
new ECFieldElement[] { FromBigInteger(p.GetZCoord(0).ToBigInteger()) },
p.IsCompressed);
default:
break;
}
}
return base.ImportPoint(p);
}
protected virtual ECFieldElement GetDenominator(int coordinateSystem, ECPoint p)
{
switch (coordinateSystem)
{
case ECCurve.COORD_HOMOGENEOUS:
case ECCurve.COORD_LAMBDA_PROJECTIVE:
case ECCurve.COORD_SKEWED:
return p.GetZCoord(0);
case ECCurve.COORD_JACOBIAN:
case ECCurve.COORD_JACOBIAN_CHUDNOVSKY:
case ECCurve.COORD_JACOBIAN_MODIFIED:
return p.GetZCoord(0).Square();
default:
return null;
}
}
