シフト系追加

GFのmodPowっぽいもの

Author: okomeki

src/main/java/net/siisise/lang/Bin.java

@@ -383,6 +383,14 @@ public static byte[] xorl(byte[] a, byte[] b) {
         return a;
     }
 
+    public static long[] xorl(long[] a, long[] b) {
+        int len = Math.min(a.length, b.length);
+        for ( int i = 0; i < len; i++ ) {
+            a[i] ^= b[i];
+        }
+        return a;
+    }
+
     /**
      * a と b の offset からの xor.
      * 
@@ -488,6 +496,7 @@ public static byte[] left(byte[] a, int shift) {
     }
 
     /**
+     * 右1bitシフト
      * @param a 元列
      * @return 右シフト
      */
@@ -500,6 +509,25 @@ public static byte[] shr(byte[] a) {
         return n;
     }    
 
+    /**
+     * 右1bitシフト
+     * @param a 非破壊
+     * @return 右シフト
+     */
+    public static int[] shr(int[] a) {
+        int[] n = new int[a.length];
+        for (int i = a.length - 1; i > 0; i--) {
+            n[i] = (a[i] >>> 1) | ( a[i - 1] << 31);
+        }
+        n[0] = a[0] >>> 1;
+        return n;
+    }    
+
+    /**
+     * 右1bitシフト
+     * @param a 非破壊
+     * @return 右シフト
+     */
     public static long[] shr(long[] a) {
         long[] n = new long[a.length];
         for (int i = a.length - 1; i > 0; i--) {
@@ -509,13 +537,35 @@ public static long[] shr(long[] a) {
         return n;
     }    
 
+    /**
+     * 右1bit rotate
+     * @param a 非破壊
+     * @return 
+     */
     public static byte[] ror(byte[] a) {
         byte b = (byte)(a[a.length - 1] << 7);
         byte[] n = shr(a);
         n[0] |= b;
         return n;
     }    
 
+    /**
+     * 右1bit rotate
+     * @param a 非破壊
+     * @return 
+     */
+    public static int[] ror(int[] a) {
+        int b = a[a.length - 1] << 31;
+        int[] n = shr(a);
+        n[0] |= b;
+        return n;
+    }    
+
+    /**
+     * 
+     * @param a 非破壊
+     * @return 
+     */
     public static long[] ror(long[] a) {
         long b = a[a.length - 1] << 63;
         long[] n = shr(a);

src/main/java/net/siisise/math/GF.java

@@ -39,22 +39,22 @@ public GF() {
     public GF(int n, int m) {
         N = n - 1;
         root = m;
-        constRb = 0; // root側を使う
+        constRb = (byte) root; // root側を使う
         size = (1 << n) - 1;
         x = new int[size + 1];
         log = new int[size + 1];
         exp = new int[size + 1];
 
-        for (int a = 0; a <= size; a++) {
-            x[a] = (a << 1) ^ ((a >>> N) * root);
-        }
+//        for (int a = 0; a <= size; a++) {
+//            x[a] = (a << 1) ^ ((a >>> N) * root);
+//        }
 
         int a = 1;
         for (int e = 0; e < size; e++) {
             log[a] = e;
             exp[e] = a;
 
-            a ^= x(a);
+            a ^= x(a); // a・3 // ・5 ・17でもいい
         }
         log[0] = 0;
         exp[size] = exp[0];
@@ -82,7 +82,7 @@ public GF(int n, byte rb) {
         log = null;
         exp = null;
     }
-
+    
     /**
      * ふつうのGF s・2
      * バイト数は未検証. てきとう.
@@ -92,7 +92,7 @@ public GF(int n, byte rb) {
     public byte[] x(byte[] s) {
         byte[] v = Bin.shl(s); // constRb に 1bit 持っているのでこっちは消す
         if (s[0] < 0) {
-            v[v.length - 1] ^= constRb;
+            v[v.length - 1] ^= constRb; // 長い用
         }
         return v;
     }
@@ -123,6 +123,25 @@ public byte[] r(byte[] s) {
         return r;
     }
 
+    /**
+     * GF s・2の逆 /2
+     * @param s・2
+     * @return s
+     */
+    public int[] r(int[] s) {
+        int[] r = Bin.ror(s); // constRb の 1bit が消えるのでこっちでつける
+        if (r[0] < 0) {
+            r[r.length - 1] ^= (constRb & 0xff) >>> 1;
+        }
+        return r;
+    }
+    
+    /**
+     * s / 2.
+     * s・2ができるならs/2も比較的単純な計算でできる 2以外はできない
+     * @param s
+     * @return 
+     */
     public long[] r(long[] s) {
         long[] r = Bin.ror(s); // constRb の 1bit が消えるのでこっちでつける
         if (r[0] < 0) {
@@ -137,13 +156,57 @@ public long[] r(long[] s) {
      * @return a・2
      */
     public final int x(int a) {
-//        return (a << 1) ^ ((a >>> N) * root); 
-        return x[a];
+        return (a << 1) ^ ((a >>> N) * root); 
+//        return x[a];
+    }
+    
+    public int r(int s) {
+        return (s >>> 1) ^ ((s & 1) * root);
     }
 
+    /**
+     * 8bit 逆数計算的なもの(高速版)
+     * @param a
+     * @return aの逆数
+     */
     public int inv(int a) {
         return a == 0 ? 0 : exp[size - log[a]];
     }
+    
+    /**
+     * 逆数計算的なもの(簡易版)
+     * @param a
+     * @return aの逆数
+     * @deprecated いろいろ間違っている
+     */
+    public byte[] inv(byte[] a) {
+        return modPow(a, (2 << (N+1)) - 2);
+    }
+    
+    /**
+     * あれ
+     * @param a
+     * @param p 1以上
+     * @return a^p mod xx
+     */
+    public byte[] modPow(byte[] a, int p) {
+        byte[] x;
+        if ( p == 1 ) {
+            return a;
+        } else {
+            if ( p % 3 == 0 ) {
+                x = modPow(a, p / 3 );
+                return mul(mul(x,x),x);
+            }
+            x = modPow(a, p / 2);
+            x = mul(x, x);
+            if ( p % 2 != 0 ) {
+                x = mul(x, a);
+//            Bin.xorl(x, a);
+            }
+        }
+        return x;
+    }
 //*    
 
     public int mul(int a, int b) {
@@ -160,6 +223,15 @@ public int mul(int a, int b) {
         return exp[e];
     }
 
+    public byte[] add(byte[] a, byte[] b) {
+        return Bin.xor(a, b);
+    }
+
+    public long[] add(long[] a, long[] b) {
+        return Bin.xor(a, b);
+    }
+
+
 /*
     public int mul(int x, int y) {
         if (x == 0 || y == 0) {
@@ -225,7 +297,7 @@ public long[] mul(long[] a, long[] b) {
         int last = a.length - 1;
         while ( !isZero(a) ) {
             if ( (a[last] & 0x01) != 0 ) {
-                r = Bin.xor(r, b);
+                Bin.xorl(r, b);
             }
             a = Bin.shr(a);
             b = x(b);

src/test/java/net/siisise/math/GFTest.java

@@ -15,6 +15,7 @@
  */
 package net.siisise.math;
 
+import java.math.BigInteger;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import net.siisise.lang.Bin;
@@ -23,7 +24,6 @@
 
 /**
  *
- * @author okome
  */
 public class GFTest {
 
@@ -73,6 +73,11 @@ public void testX_byteArr() {
         byte[] expResult = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,(byte)0x85};
         byte[] result = gf.x(s);
         assertArrayEquals(expResult, result);
+        s = new byte[] {(byte)0x80};
+        gf = new GF();
+        expResult = new byte[] {0x1b};
+        result = gf.x(s);
+        assertArrayEquals(expResult, result);
     }
 
     /**
@@ -100,4 +105,61 @@ public void testX_int() {
         int result = instance.x(a);
         assertEquals(expResult, result);
     }
+
+    /**
+     *  3  0b00000011
+     *  5  0b00000101
+     * 17  0b00010001
+     * 0x11b 0b100011011 283 256 + 16 + 8 + 2 + 1
+     */
+    @Test
+    public void testXXX() {
+        System.out.println();
+        BigInteger ff = BigInteger.valueOf(0x11b);
+        GF gf = new GF(8, 0x11b);
+        // 100011011
+        // 279
+        int x = 3;
+        int x5 = 5;
+        for ( int i = 1; i < 0x100; i++ ) {
+            System.out.print("x = 0x" + Integer.toHexString(i));
+            System.out.print(" = " + i);
+            System.out.print(" 2x = " + Integer.toHexString(gf.x(i)));
+            System.out.print(" x^2 = " + Integer.toHexString(gf.mul(i,i)));
+            System.out.print(" x^2 + x = 0x" + Integer.toHexString(gf.mul(i,i)));
+            System.out.print(" = " + gf.mul(i,i));
+            byte[] n = new byte[1];
+            n[0] = (byte)i;
+            n = gf.inv(n);
+            System.out.print(" inv = 0x" + Integer.toHexString(n[0]));
+            System.out.print(" = " + Integer.toHexString(gf.inv(i)));
+            System.out.print(" = " + gf.inv(i));
+            System.out.print(" 3^"+i+"= " + Integer.toHexString(x));
+            System.out.print(" inv = 0x" + Integer.toHexString(gf.inv(x)));
+            x = gf.mul(x,3);
+            System.out.print(" 5^"+i+"= " + Integer.toHexString(x5));
+            System.out.print(" inv = 0x" + Integer.toHexString(gf.inv(x5)));
+            x5 = gf.mul(x5,5);
+            System.out.print(" mod3 " + i % 3);
+            System.out.print(" mod5 " + i % 5);
+            System.out.print(" mod17 " + i % 17);
+            System.out.print(" mod3 " + gf.inv(i) % 3);
+            System.out.print(" mod5 " + gf.inv(i) % 5);
+            System.out.println(" mod17 " + gf.inv(i) % 17);
+        }
+        
+        
+        System.out.println("e 6 inv " + gf.mul(0x8d, 0xf6));
+        System.out.println("e 6 inv " + gf.inv(gf.mul(0x8d, 0xf6)));
+    }
+    
+    public void testLongGF() {
+        System.out.println("longGF");
+        GF gf = new GF(8,GF.FF8);
+        byte[] a = new byte[1];
+        byte[] b = new byte[1];
+        byte[] c;
+        c = gf.mul(a, b);
+        System.out.println(Bin.toHex(c));
+    }
 }