public FiniteFieldElement <IntegerType> Divide(
FiniteFieldElement <IntegerType> element_0,
FiniteFieldElement <IntegerType> element_1)
{
FiniteFieldElement <IntegerType> inverse = MutiplicativeInverse(element_1);
return(new FiniteFieldElement <IntegerType>(this, Algebra.Modulo(Algebra.Multiply(element_0.Value, inverse.Value), Prime)));
}
public FiniteFieldElement <uint>[] GetElements()
{
FiniteFieldElement <uint>[] elements = new FiniteFieldElement <uint> [256];
for (int index = 0; index < 256; index++)
{
elements[index] = new FiniteFieldElement <uint>(this, (uint)index);
}
return(elements);
}
public FiniteFieldElement <IntegerType> ToDomain(BigInteger value)
{
FiniteFieldElement <IntegerType> element = new FiniteFieldElement <IntegerType>(this, Algebra.ToDomain(value));
if (!Contains(element))
{
throw new Exception("Cannot convert to domain");
}
return(element);
}
public FiniteFieldElement <byte> Divide(FiniteFieldElement <byte> value_0, FiniteFieldElement <byte> value_1)
{
if ((value_0.Value == 0) || (value_1.Value == 0))
{
return(new FiniteFieldElement <byte>(this, 0));
}
byte result = (byte)((((value_0.Value - value_1.Value) + size) - 1) % (size - 1) + 1);
return(new FiniteFieldElement <byte>(this, result));
}
public FiniteFieldElement <byte>[] GetElements()
{
FiniteFieldElement <byte>[] elements = new FiniteFieldElement <byte> [(int)size];
for (int index = 0; index < elements.Length; index++)
{
elements[index] = new FiniteFieldElement <byte>(this, (byte)index);
}
return(elements);
}
public AlgebraFiniteFieldGenericPrime(IAlgebraInteger <IntegerType> algebra, IntegerType prime)
{
if (!ToolsMathBigIntegerPrime.IsPrime(algebra.ToBigInteger(prime)))
{
throw new Exception("Number " + prime.ToString() + " is not prime");
}
Prime = prime;
Algebra = algebra;
ElementCount = Algebra.ToBigInteger(prime);
AddIdentity = new FiniteFieldElement <IntegerType>(this, Algebra.AddIdentity);
MultiplyIdentity = new FiniteFieldElement <IntegerType>(this, Algebra.MultiplyIdentity);
}
public override bool Equals(object other)
{
if (other is FiniteFieldElement <DomainType> )
{
FiniteFieldElement <DomainType> other_typed = (FiniteFieldElement <DomainType>)other;
return(this == other_typed);
}
else
{
return(false);
}
}
public FiniteFieldElement <int> Divide(
FiniteFieldElement <int> element_0,
FiniteFieldElement <int> element_1)
{
if (Math.Min(element_0.Value, element_1.Value) == 0)
{
return(new FiniteFieldElement <int>(this, 0));
}
FiniteFieldElement <int> inverse = MutiplicativeInverse(element_1); //TODO really expensive for big fields
return(new FiniteFieldElement <int>(this, (gf_mult(element_0.Value, element_1.Value))));
}
public FiniteFieldElement <byte> Multiply(
FiniteFieldElement <byte> value_0,
FiniteFieldElement <byte> value_1)
{
if ((value_0.Value == 0) || (value_1.Value == 0))
{
return(new FiniteFieldElement <byte>(this, 0));
}
byte result = (byte)(((value_0.Value + value_1.Value - 2) % (size - 1)) + 1);
return(new FiniteFieldElement <byte>(this, result));
}
public FiniteFieldElement <IntegerType> [] GetElements()
{
if (1000000 < ElementCount)
{
throw new Exception("Groups is to big, you do not want this");
}
FiniteFieldElement <IntegerType> [] elements = new FiniteFieldElement <IntegerType> [(int)ElementCount];
for (int index = 0; index < elements.Length; index++)
{
elements[index] = new FiniteFieldElement <IntegerType>(this, Algebra.ToDomain(index));
}
return(elements);
}
public FiniteFieldElement <int> [] GetElements()
{
if (1000000 < size)
{
throw new Exception("Groups is to big, you do not want this");
}
FiniteFieldElement <int> [] elements = new FiniteFieldElement <int> [(int)size];
for (int index = 0; index < elements.Length; index++)
{
elements[index] = new FiniteFieldElement <int>(this, index);
}
return(elements);
}
private FiniteFieldElement <int> MutiplicativeInverse(FiniteFieldElement <int> element)
{
FiniteFieldElement <int>[] elements = GetElements();
FiniteFieldElement <int> indentity = MultiplyIdentity;
for (int element_index = 0; element_index < elements.Length; element_index++)
{
if (element * elements[element_index] == indentity)
{
return(elements[element_index]);
}
}
throw new Exception("Mutiplicative Inverse should always exist also for " + element);
}
public static void CheckFieldDistributivity <ElementType>(
IAlgebraFieldFinite <ElementType> field)
{
FiniteFieldElement <ElementType>[] elements = field.GetElements();
// check distributivity a X (b + c) = (a X b) + (a X c).
for (int index_0 = 0; index_0 < elements.Length; index_0++)
{
for (int index_1 = 0; index_1 < elements.Length; index_1++)
{
for (int index_2 = 0; index_2 < elements.Length; index_2++)
{
FiniteFieldElement <ElementType> result_0 = (elements[index_0] + elements[index_1]) * elements[index_2];
FiniteFieldElement <ElementType> result_1 = (elements[index_0] * elements[index_2]) + (elements[index_1] * elements[index_2]);
Assert.AreEqual(result_0, result_1);
}
}
}
}
public static void CheckFieldIdentities <ElementType>(
IAlgebraFieldFinite <ElementType> field)
{
FiniteFieldElement <ElementType>[] elements = field.GetElements();
FiniteFieldElement <ElementType> add_identity = field.AddIdentity;
FiniteFieldElement <ElementType> multiply_identity = field.MultiplyIdentity;
Assert.AreNotEqual(add_identity, multiply_identity, "add_identiy should be different from multiply_identity");
// check identity elements
for (int index_0 = 0; index_0 < elements.Length; index_0++)
{
Assert.AreEqual(elements[index_0], elements[index_0] + add_identity, elements[index_0] + " + " + add_identity + " should yield " + elements[index_0] + " but yielded " + (elements[index_0] + add_identity));
Assert.AreEqual(elements[index_0], add_identity + elements[index_0], add_identity + " + " + elements[index_0] + " should yield " + elements[index_0] + " but yielded " + (add_identity + elements[index_0]));
Assert.AreEqual(elements[index_0], elements[index_0] * multiply_identity, elements[index_0] + " * " + multiply_identity + " should yield " + elements[index_0] + " but yielded " + (elements[index_0] * multiply_identity));
Assert.AreEqual(elements[index_0], multiply_identity * elements[index_0], multiply_identity + " * " + elements[index_0] + " should yield " + elements[index_0] + " but yielded " + (multiply_identity * elements[index_0]));
}
}
/* Multiply two numbers in the GF(2^8) finite field defined
* by the polynomial x^8 + x^4 + x^3 + x + 1 = 0 */
public FiniteFieldElement <uint> Multiply(FiniteFieldElement <uint> value_0, FiniteFieldElement <uint> value_1)
{
uint a = value_0.Value;
uint b = value_1.Value;
uint p = 0;
uint counter;
uint carry;
for (counter = 0; counter < 8; counter++)
{
if ((b & 1) == 0)
{
p ^= a;
}
carry = (a & 0x80); /* detect if x^8 term is about to be generated */
a <<= 1;
if (carry == 0)
{
a ^= 0x1B; /* replace x^8 with x^4 + x^3 + x + 1 */
}
b >>= 1;
}
return(new FiniteFieldElement <uint>(this, p));
}
public FiniteFieldElement <int> Multiply(
FiniteFieldElement <int> element_0,
FiniteFieldElement <int> element_1)
{
return(new FiniteFieldElement <int>(this, gf_mult(element_0.Value, element_1.Value)));
}
public FiniteFieldElement <int> Subtract(
FiniteFieldElement <int> element_0,
FiniteFieldElement <int> element_1)
{
return(new FiniteFieldElement <int>(this, (element_0.Value ^ element_1.Value)));
}
public bool Contains(FiniteFieldElement <int> input)
{
return(input.Algebra == this);
}
public FiniteFieldElement <BigInteger> Subtract(
FiniteFieldElement <BigInteger> element_0,
FiniteFieldElement <BigInteger> element_1)
{
return(new FiniteFieldElement <BigInteger>(this, element_0.Value ^ element_1.Value));
}
public int ToInt32(FiniteFieldElement <int> value)
{
throw new NotImplementedException();
}
public BigInteger ToBigInteger(FiniteFieldElement <int> value)
{
throw new NotImplementedException();
}
public int ToInt32(FiniteFieldElement <IntegerType> value)
{
return(Algebra.ToInt32(value.Value));
}
private FiniteFieldElement <IntegerType> MutiplicativeInverse(FiniteFieldElement <IntegerType> element_0)
{
Tuple <IntegerType, IntegerType, IntegerType> xyd = ToolsMath.ExtendedEuclideanAlgorithm(Algebra, element_0.Value, Prime);
return(new FiniteFieldElement <IntegerType>(this, Algebra.Modulo(xyd.Item1, Prime)));
}
public FiniteFieldElement <DomainType> Multiply(
FiniteFieldElement <DomainType> other)
{
return(Algebra.Multiply(this, other));
}
public bool Contains(FiniteFieldElement <IntegerType> input)
{
return(input.Algebra == this);
}
public FiniteFieldElement <BigInteger> Multiply(
FiniteFieldElement <BigInteger> element_0,
FiniteFieldElement <BigInteger> element_1)
{
return(new FiniteFieldElement <BigInteger>(this, ((element_0.Value + element_1.Value - 2) % (size - 1)) + 1));
}
public FiniteFieldElement <BigInteger> Divide(
FiniteFieldElement <BigInteger> value_0,
FiniteFieldElement <BigInteger> value_1)
{
return(new FiniteFieldElement <BigInteger>(this, (((value_0.Value - value_1.Value) + size) - 1) % (size - 1) + 1));
}
public FiniteFieldElement <DomainType> Divide(
FiniteFieldElement <DomainType> other)
{
return(Algebra.Divide(this, other));
}
public FiniteFieldElement <IntegerType> Multiply(
FiniteFieldElement <IntegerType> element_0,
FiniteFieldElement <IntegerType> element_1)
{
return(new FiniteFieldElement <IntegerType>(this, Algebra.Modulo(Algebra.Multiply(element_0.Value, element_1.Value), Prime)));
}
public BigInteger ToBigInteger(FiniteFieldElement <IntegerType> value)
{
return(Algebra.ToBigInteger(value.Value));
}
