Пример #1
0
        /**
         * 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]);
            }
        }
Пример #2
0
        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;
            }
        }
Пример #3
0
        /**
         * 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]);
            }
        }
Пример #4
0
        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]);
                }
            }
        }
Пример #5
0
 public static void MontgomeryTrick(ECFieldElement[] zs, int off, int len)
 {
     ECAlgorithms.MontgomeryTrick(zs, off, len, null);
 }