Example #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]);
            }
        }
Example #2
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]);
            }
        }
Example #3
0
    public virtual void NormalizeAll(ECPoint[] points, int off, int len, ECFieldElement iso)
    {
        CheckPoints(points, off, len);
        int coordinateSystem = CoordinateSystem;

        if (coordinateSystem == 0 || coordinateSystem == 5)
        {
            if (iso != null)
            {
                throw new ArgumentException("not valid for affine coordinates", "iso");
            }
            return;
        }
        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)
        {
            ECAlgorithms.MontgomeryTrick(array, 0, num, iso);
            for (int j = 0; j < num; j++)
            {
                int num3 = array2[j];
                points[num3] = points[num3].Normalize(array[j]);
            }
        }
    }