Die folgenden Zeilen sollen led. als Teil einer möglichen Lösung zu verstehen sein!

Zuerst einmal vielen Dank, dass du meine Frage als Link mit integriert hast. Da ich vor einem ähnlichen Problem stehe, hier mal den Ansatzpunkt meiner Überlegungen.

Ich wollte das Ergebnis mit mehreren ulongs erzielen. Da ich keine Zeit f. Versuche damit bisher hatte (fast 24 Std.-Arbeitstag), habe ich dir ein Fragment aus dem Kopf aufgezeichnet, welches ev. Fehler enthalten kann, weil ich das nicht ausprobiert habe. Auf ähnliche Art kann das aber funktionieren.

Du möchtest 3 Arten der Berechnung durchführen, wobei XOR kein Problem darstellen sollte. Multiplikation musst du selbst noch mal schauen, ob du das rein mathematisch irgendwie lösen kannnst. Rotation könnte auf einem ähnlichen Weg gemacht werden, wie das folgende Fragment zeigt:

n ist die Anzahl der Verschiebungen (möglich ist hier leider nur max. 64)
u sind 2 ulongs, die zusammenhängend rotiert werden sollen

public static ulong[] test(ulong[] u, int n)
  {
   ulong tmp1 = u[0], tmp2 = u[1];
   
   u[0] = u[0] << n;
   u[1] = u[1] >> n;
   u[0] = u[0] | u[1];
   
   u[1] = tmp2 << n;
   tmp2 = tmp1 >> n;
   u[1] = u[1] | tmp2;
   return u;
  }

Wie gesagt - ungetestet!!! Vielleicht hilft es ja als Denkanstoss.


Update

In meinem obigen Fragment steckten Fehler. Ich habe gerade einen Moment Zeit gefunden und hier ist nun die Lösung für eine Linksrotation für 128 Bit (Verarbeitung mit 2 ulongs).

Aufruf:

using System;
using System.Text;

 class Program
 {
  public static void Main(string[] args)
  {
   ulong[] dUl = new ulong[2];

   dUl[0] = uint.MaxValue;
   dUl[1] = 1;
   
   string s1 = ConvertToBinary(dUl[0]);
   string s2 = ConvertToBinary(dUl[1]);
   
   Console.WriteLine(s1 + "-" + s2);
   
   int n = 68;
   int n2 = 128 - n;
   dUl = TwoUlongRotation.RotL(dUl, n);
   s1 = ConvertToBinary(dUl[0]);
    s2 = ConvertToBinary(dUl[1]);
    Console.WriteLine(s1 + "-" + s2);
   dUl = TwoUlongRotation.RotL(dUl, n2);
   s1 = ConvertToBinary(dUl[0]);
    s2 = ConvertToBinary(dUl[1]);
    Console.WriteLine(s1 + "-" + s2);

   Console.Write("\nPress any key to continue . . . ");
   Console.ReadKey(true);
  }
  
  private static string ConvertToBinary(ulong value)
  {
     if(value==0)
      return "0";
     int i = 64;
     System.Text.StringBuilder b=new System.Text.StringBuilder();

     while(i-- > -1)
     {
       b.Insert(0,((value&1)==1) ? '1' : '0');
       value>>=1;
     }
     return b.ToString();
  }
 }

 /*Statische Klasse*/
 internal static class TwoUlongRotation
 {
  internal static ulong[] RotL(ulong[] u, int n)
  {
   ulong t1h, t1l, t2h, t2l;
   n %= 128;
   
   if(n == 128)
    return u;
   
   if(n == 64)
   {
    t1h = u[0];
    u[0] = u[1];
    u[1] = t1h;
    return u;    
   }
   
   if(n > 64)
   {
    t1h = u[0];
    u[0] = u[1];
    u[1] = t1h;
    n -=64;
   }

     t1h = u[0] << n; t1l = u[0] >> (64 - n);
     t2h = u[1] << n; t2l = u[1] >> (64 - n);
      u[0] = t1h | t2l; u[1] = t2h | t1l;
   return u; 
  }
 }

Ich hatte für die Erstellung nur 20 Min. Zeit. Falls jetzt noch was nicht ganz richtig laufen sollte, kannst du das bestímmt leicht selbst korrigieren. Mit etwas Ausbau kann man auf diese Art fast jede erdenkliche Blockgrösse rotieren. Ich hoffe das hilft schon mal etwas.