Thu Aug 15 05:47:44 PM EDT 2024

diff --git a/src/bytecode.c b/src/bytecode.c
index 9a73886ff89f3a43385171eb395fd1d7f1d6081f..8ed1edb99b9971872a61fdb4b097eb8dab9d68c1 100644 (file)
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -61,7 +61,15 @@ float qansel_rand_t(QAnselContext* ctx)
                        unsigned char r = 0;
                        switch (ctx->hardware_rng)
                        {
-                               case QANSEL_HARDWARE_TRUERNG: r = fgetc(ctx->random_file); break;
+                               case QANSEL_HARDWARE_TRUERNG:
+                                       r = fgetc(ctx->random_file);
+                                       ctx->buffer_pos += 1;
+                                       if (ctx->buffer_pos >= ctx->buffer_size)
+                                       {
+                                               fclose(ctx->random_file);
+                                               ctx->random_file = fopen(ctx->random_path, "r");
+                                       }
+                                       break;
                                case QANSEL_HARDWARE_RDSEED: r = qansel_hardware_rand(); break;
                        }
                        num = (num << 8) | r;

diff --git a/src/context.c b/src/context.c
index f21b5342b1e04f9cb3283d579d5a853088d8b4b1..60ff181f49a2e4d31c7a5ed5a40e10465633ab17 100644 (file)
--- a/src/context.c
+++ b/src/context.c
@@ -68,24 +68,38 @@ int qanselContextBegin(QAnselContext* ctx)
 
        if (ctx->hardware_rng == QANSEL_HARDWARE_AUTO)
        {
-               ctx->random_file = fopen("/dev/TrueRNG0", "r");
+               ctx->random_file = fopen("/dev/qrandom0", "r");
                if (ctx->random_file == NULL)
                {
-                       if (qansel_hardware_rand_supported())
+                       ctx->random_file = fopen("/dev/TrueRNG0", "r");
+                       if (ctx->random_file == NULL)
                        {
-                               if (ctx->verbose) printf("QAnsel: Hardware `Intel Secure Key Technology` selected.\n");
-                               ctx->hardware_rng = QANSEL_HARDWARE_RDSEED;
+                               if (qansel_hardware_rand_supported())
+                               {
+                                       if (ctx->verbose) printf("QAnsel: Hardware `Intel Secure Key Technology` selected.\n");
+                                       ctx->hardware_rng = QANSEL_HARDWARE_RDSEED;
+                               }
+                               else
+                               {
+                                       fprintf(stderr, "QAnsel: No supported hardware random number generator found.\n");
+                                       return 0;
+                               }
                        }
                        else
                        {
-                               fprintf(stderr, "QAnsel: No supported hardware random number generator found.\n");
-                               return 0;
+                               if (ctx->verbose) printf("QAnsel: Hardware `TrueRNG` selected.\n");
+                               strcpy(ctx->random_path, "/dev/TrueRNG0");
+                               ctx->hardware_rng = QANSEL_HARDWARE_TRUERNG;
+                               ctx->buffer_size = -1;
                        }
                }
                else
                {
-                       if (ctx->verbose) printf("QAnsel: Hardware `TrueRNG` selected.\n");
+                       if (ctx->verbose) printf("QAnsel: Hardware `Quantis` selected.\n");
+                       strcpy(ctx->random_path, "/dev/qrandom0");
                        ctx->hardware_rng = QANSEL_HARDWARE_TRUERNG;
+                       ctx->buffer_size = 65535;
+                       ctx->buffer_pos = 0;
                }
        }
        if (ctx->optimization_level & QANSEL_MODE_METAL)

diff --git a/src/context.h b/src/context.h
index 40374fbe556aaeb262f06c89eca6927e33ac8925..39d1da21252f4a6bb893c160b7c2dd6b2992b1a9 100644 (file)
--- a/src/context.h
+++ b/src/context.h
@@ -19,6 +19,9 @@ typedef struct
        int bsampling_shots;
        int qubit_count;
        int bit_count;
+       int buffer_size;
+       int buffer_pos;
+       char random_path[256];
        FILE* random_file;
 } QAnselContext;
 

diff --git a/src/imports/bloch-sphere.html b/src/imports/bloch-sphere.html
index a0742e38d4a578c7c69173a8019894784cc38b71..ae4b53f8caadd50dfb242ca274d1f77bab379d31 100644 (file)
--- a/src/imports/bloch-sphere.html
+++ b/src/imports/bloch-sphere.html
@@ -47,6 +47,11 @@
                        useColor = false;
                }
                var gate = {};
+               gate.i =
+               [
+                       [1, 0], [0, 0],
+                       [0, 0], [1, 0],
+               ];
                gate.x =
                [
                        [0, 0], [1, 0],
@@ -63,6 +68,10 @@
                        [0, 0], [-1, 0],
                ];
                var R = 1/Math.sqrt(2);
+               [
+                       [ 1, 0 ], [ 0, 0 ],
+                       [ 0, 0 ], [ 1, 0 ],
+               ];
                gate.h = 
                [
                        [ R, 0 ], [ R, 0 ],
@@ -90,6 +99,96 @@
                ];
                gate.reset = "reset";
                gate.measure = "measure";
+               gate.add = function(a, b)
+               {
+                       var ret =
+                       [
+                               [0, 0], [0, 0],
+                               [0, 0], [0, 0]
+                       ];
+                       for (var i = 0; i < ret.length; i++)
+                       {
+                               ret[i] = complex.add(a[i], b[i]);
+                       }
+                       return ret;
+               };
+               gate.mul1 = function(a, b)
+               {
+                       var ret =
+                       [
+                               [0, 0], [0, 0],
+                               [0, 0], [0, 0]
+                       ];
+                       for (var i = 0; i < ret.length; i++)
+                       {
+                               ret[i] = complex.multiply(a[i], b);
+                       }
+                       return ret;
+               };
+               gate.copy = function(a)
+               {
+                       var ret =
+                       [
+                               [0, 0], [0, 0],
+                               [0, 0], [0, 0]
+                       ];
+                       for (var i = 0; i < ret.length; i++)
+                       {
+                               ret[i] = a[i];
+                       }
+                       return ret;
+               };
+               gate.div1 = function(a, b)
+               {
+                       var ret =
+                       [
+                               [0, 0], [0, 0],
+                               [0, 0], [0, 0]
+                       ];
+                       for (var i = 0; i < ret.length; i++)
+                       {
+                               ret[i] = complex.divide(a[i], b);
+                       }
+                       return ret;
+               };
+               gate.pow1 = function(a, b)
+               {
+                       var ret =
+                       [
+                               [0, 0], [0, 0],
+                               [0, 0], [0, 0]
+                       ];
+                       for (var i = 0; i < ret.length; i++)
+                       {
+                               ret[i] = complex.power(a[i], b);
+                       }
+                       return ret;
+               };
+               gate.exp = (g, p) =>
+               {
+                       var ret = gate.copy(gate.i);
+                       for (var i = 0; i < p; i++)
+                       {
+                               var tmp = gate.copy(g);
+                               gate.div(tmp, factorial(i + 1));
+                               ret = gate.add(ret, tmp);
+                       }
+                       return ret;
+               };
+               gate.log = (g, p) =>
+               {
+                       var ret = gate.add(g, gate.mul1(gate.i, [-1, 0]));
+                       for (var i = 2; i < p; i++)
+                       {
+                               console.log(i + ": " + (i % 2 == 0 ? " - " : " + ") + "(1/" + i + ")(A - I)^" + i);
+                               var tmp = gate.add(g, gate.mul1(gate.i, [-1, 0]));
+                               tmp = gate.pow1(tmp, i);
+                               tmp = gate.div1(tmp, [i, 0]);
+                               if (i % 2 == 0) tmp = gate.mul1(tmp, [-1, 0]);
+                               ret = gate.add(ret, tmp);
+                       }
+                       return ret;
+               };
 
                var complex = {};
                complex.multiply = (a, b) =>
@@ -115,6 +214,27 @@
                {
                        return Math.sqrt( Math.pow(a[0], 2) + Math.pow(a[1], 2) );
                };
+               complex.power = (a, n) =>
+               {
+                       const r = Math.sqrt(a[0] * a[0] + a[1] * a[1]);
+                       const theta = Math.atan2(a[1], a[0]);
+                       const rPowerN = Math.pow(r, n);
+                       const newTheta = n * theta;
+                       const realPart = rPowerN * Math.cos(newTheta);
+                       const imaginaryPart = rPowerN * Math.sin(newTheta);
+                       return [realPart, imaginaryPart];
+               };
+               complex.divide = (a, b) =>
+               {
+                       d = b[1];
+                       c = b[0];
+                       b = a[1];
+                       a = a[0];
+                       var denominator = c * c + d * d;
+                       var realPart = (a * c + b * d) / denominator;
+                       var imaginaryPart = (b * c - a * d) / denominator;
+                       return [realPart, imaginaryPart];
+               };
 
                var qubit = {};
                qubit.state = [ [1, 0], [0, 0] ];
@@ -235,6 +355,14 @@
             return sprite;
         }
 
+               function factorial(n)
+               {
+                       if (n === 0 || n === 1)
+                       {
+                               return 1;
+                       }
+                       return n * factorial(n - 1);
+               }
                /*
         var sphereCenterY = sphere.position.y; // Y position of the sphere's center
         var sphereRadius = 1; // Radius of the sphere

diff --git a/src/index.html b/src/index.html
index 24bba2b8576f971526a8bca7383539cb6096755d..156a26d120d475f436d00acc98feb092e276078d 100644 (file)
--- a/src/index.html
+++ b/src/index.html
@@ -334,7 +334,8 @@
                                        }
                                        if (maxQ >= 0)
                                        {
-                                               ret = "qreg q[" + (maxQ + 1) + "];\n" + ret;
+//                                             ret = "qreg q[" + (maxQ + 1) + "];\n" + ret;
+                                               ret = "qreg q[" + ($("[pidx*=',0'").length - 1) + "];\n" + ret;
                                                if (maxC >= 0)
                                                {
                                                        ret += "sample c;\n";