HillEncoder.cs

usingSystem;
usingSystem.Linq;
usingAlgorithms.Numeric;

namespaceAlgorithms.Encoders;

/// <summary>
/// Lester S. Hill's polygraphic substitution cipher,
/// without representing letters using mod26, using
/// corresponding "(char)value" instead.
/// </summary>
publicclassHillEncoder:IEncoder<double[,]>
{
privatereadonlyGaussJordanEliminationlinearEquationSolver;

publicHillEncoder()=>linearEquationSolver=newGaussJordanElimination();// TODO: add DI

publicstringEncode(stringtext,double[,]key)
{
varpreparedText=FillGaps(text);
varchunked=ChunkTextToArray(preparedText);
varsplitted=SplitToCharArray(chunked);

varciphered=newdouble[chunked.Length][];

for(vari=0;i<chunked.Length;i++)
{
varvector=newdouble[3];
Array.Copy(splitted,i*3,vector,0,3);
varproduct=MatrixCipher(vector,key);
ciphered[i]=product;
}

varmerged=MergeArrayList(ciphered);

returnBuildStringFromArray(merged);
}

publicstringDecode(stringtext,double[,]key)
{
varchunked=ChunkTextToArray(text);
varsplit=SplitToCharArray(chunked);

vardeciphered=newdouble[chunked.Length][];

for(vari=0;i<chunked.Length;i++)
{
varvector=newdouble[3];
Array.Copy(split,i*3,vector,0,3);
varproduct=MatrixDeCipher(vector,key);
deciphered[i]=product;
}

varmerged=MergeArrayList(deciphered);
varstr=BuildStringFromArray(merged);

returnUnFillGaps(str);
}

/// <summary>
/// Converts elements from the array to their corresponding Unicode characters.
/// </summary>
/// <param name="arr">array of vectors.</param>
/// <returns>Message.</returns>
privatestaticstringBuildStringFromArray(double[]arr)=>new(arr.Select(c =>(char)c).ToArray());

/// <summary>
/// Multiplies the key for the given scalar.
/// </summary>
/// <param name="vector">list of splitted words as numbers.</param>
/// <param name="key">Cipher selected key.</param>
/// <returns>Ciphered vector.</returns>
privatestaticdouble[]MatrixCipher(double[]vector,double[,]key)
{
varmultiplied=newdouble[vector.Length];

for(vari=0;i<key.GetLength(1);i++)
{
for(varj=0;j<key.GetLength(0);j++)
{
multiplied[i]+=key[i,j]*vector[j];
}
}

returnmultiplied;
}

/// <summary>
/// Given a list of vectors, returns a single array of elements.
/// </summary>
/// <param name="list">List of ciphered arrays.</param>
/// <returns>unidimensional list.</returns>
privatestaticdouble[]MergeArrayList(double[][]list)
{
varmerged=newdouble[list.Length*3];

for(vari=0;i<list.Length;i++)
{
Array.Copy(list[i],0,merged,i*3,list[0].Length);
}

returnmerged;
}

/// <summary>
/// Splits the input text message as chunks of words.
/// </summary>
/// <param name="chunked">chunked words list.</param>
/// <returns>spliiter char array.</returns>
privatestaticchar[]SplitToCharArray(string[]chunked)
{
varsplitted=newchar[chunked.Length*3];

for(vari=0;i<chunked.Length;i++)
{
for(varj=0;j<3;j++)
{
splitted[i*3+j]=chunked[i].ToCharArray()[j];
}
}

returnsplitted;
}

/// <summary>
/// Chunks the input text message.
/// </summary>
/// <param name="text">text message.</param>
/// <returns>array of words.</returns>
privatestaticstring[]ChunkTextToArray(stringtext)
{
// To split the message into chunks
vardiv=text.Length/3;
varchunks=newstring[div];

for(vari=0;i<div;i++)
{
chunks.SetValue(text.Substring(i*3,3),i);
}

returnchunks;
}

/// <summary>
/// Fills a text message with spaces at the end
/// to enable a simple split by 3-length-word.
/// </summary>
/// <param name="text">Text Message.</param>
/// <returns>Modified text Message.</returns>
privatestaticstringFillGaps(stringtext)
{
varremainder=text.Length%3;
returnremainder==0?text:text+newstring(' ',3-remainder);
}

/// <summary>
/// Removes the extra spaces included on the cipher phase.
/// </summary>
/// <param name="text">Text message.</param>
/// <returns>Deciphered Message.</returns>
privatestaticstringUnFillGaps(stringtext)=>text.TrimEnd();

/// <summary>
/// Finds the inverse of the given matrix using a linear equation solver.
/// </summary>
/// <param name="vector">Splitted words vector.</param>
/// <param name="key">Key used for the cipher.</param>
/// <returns>TODO.</returns>
privatedouble[]MatrixDeCipher(double[]vector,double[,]key)
{
// To augment the original key with the given vector.
varaugM=newdouble[3,4];

for(vari=0;i<key.GetLength(0);i++)
{
for(varj=0;j<key.GetLength(1);j++)
{
augM[i,j]=key[i,j];
}
}

for(vark=0;k<vector.Length;k++)
{
augM[k,3]=vector[k];
}

_=linearEquationSolver.Solve(augM);

returnnew[]{augM[0,3],augM[1,3],augM[2,3]};
}
}