PointOnCurve.cs

using System.Text;
using System.Numerics;
 
namespace Waher.Security.EllipticCurves
{
    public struct PointOnCurve
    {
        private BigInteger x;
        private BigInteger y;
        private BigInteger z;
        private BigInteger t;
        private bool nonzero;
        private bool homogeneous;
 
        public PointOnCurve(PointOnCurve P)
        {
            this.x = P.x;
            this.y = P.y;
            this.z = P.z;
            this.t = P.t;
            this.nonzero = P.nonzero;
            this.homogeneous = P.homogeneous;
        }
 
        public PointOnCurve(BigInteger X, BigInteger Y)
        {
            this.x = X;
            this.y = Y;
            this.z = BigInteger.One;
            this.t = BigInteger.Zero;
            this.nonzero = !X.IsZero || !Y.IsZero;
            this.homogeneous = false;
        }
 
        public PointOnCurve(BigInteger X, BigInteger Y, BigInteger Z)
        {
            this.x = X;
            this.y = Y;
            this.z = Z;
            this.t = BigInteger.Zero;
            this.nonzero = !X.IsZero || !Y.IsZero;
            this.homogeneous = true;
        }
 
        public PointOnCurve(BigInteger X, BigInteger Y, BigInteger Z, BigInteger T)
        {
            this.x = X;
            this.y = Y;
            this.z = Z;
            this.t = T;
            this.nonzero = !X.IsZero || !Y.IsZero;
            this.homogeneous = true;
        }
 
        public BigInteger X
        {
            get => this.x;
            internal set => this.x = value;
        }
 
        public BigInteger Y
        {
            get => this.y;
            internal set => this.y = value;
        }
 
        public BigInteger Z
        {
            get => this.z;
            internal set
            {
                this.z = value;
                this.homogeneous = true;
            }
        }
 
        public BigInteger T
        {
            get => this.t;
            internal set
            {
                this.t = value;
                this.homogeneous = true;
            }
        }
 
        public bool NonZero
        {
            get => this.nonzero;
            internal set => this.nonzero = value;
        }
 
        public bool IsHomogeneous
        {
            get => this.homogeneous;
            internal set => this.homogeneous = value;
        }
 
        public bool IsXZero => this.x.IsZero;
 
        public bool IsYZero => this.y.IsZero;
 
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append('(');
            sb.Append(this.x.ToString());
            sb.Append(',');
            sb.Append(this.y.ToString());
 
            if (this.homogeneous)
            {
                sb.Append(',');
                sb.Append(this.z.ToString());
                sb.Append(',');
                sb.Append(this.t.ToString());
            }
 
            sb.Append(')');
 
            return sb.ToString();
        }
 
        public override bool Equals(object obj)
        {
            return obj is PointOnCurve P &&
                this.x.Equals(P.x) &&
                this.y.Equals(P.y) &&
                this.z.Equals(P.z) &&
                this.t.Equals(P.t) &&
                this.nonzero.Equals(P.nonzero) &&
                this.homogeneous.Equals(P.homogeneous);
        }
 
        public override int GetHashCode()
        {
            return
                this.x.GetHashCode() ^
                this.y.GetHashCode() ^
                this.z.GetHashCode() ^
                this.t.GetHashCode() ^
                this.nonzero.GetHashCode() ^
                this.homogeneous.GetHashCode();
        }
 
        public void CopyFrom(PointOnCurve C)
        {
            this.x = C.x;
            this.y = C.y;
            this.z = C.z;
            this.t = C.t;
            this.nonzero = C.nonzero;
            this.homogeneous = C.homogeneous;
        }
 
        public void Normalize(PrimeFieldCurve Curve)
        {
            if (this.homogeneous)
            {
                this.x = Curve.ModulusP.Divide(this.x, this.z);
                this.y = Curve.ModulusP.Divide(this.y, this.z);
                this.z = BigInteger.One;
                this.t = BigInteger.Zero;
                this.homogeneous = false;
            }
 
            if (this.x.Sign < 0)
                this.x += Curve.Prime;
 
            if (this.y.Sign < 0)
                this.y += Curve.Prime;
        }
    }
}