updated libquantum 1.1.1 source files

qureg.c

@@ -1,6 +1,6 @@
 /* qureg.c: Quantum register management
 
-   Copyright 2003, 2004, 2006 Bjoern Butscher, Hendrik Weimer
+   Copyright 2003-2013 Bjoern Butscher, Hendrik Weimer
 
    This file is part of libquantum
 
@@ -59,12 +59,13 @@ quantum_matrix2qureg(quantum_matrix *m, int width)
   reg.size = size;
   reg.hashw = width + 2;
 
-  reg.node = calloc(size, sizeof(quantum_reg_node));
+  reg.amplitude = calloc(size, sizeof(COMPLEX_FLOAT));
+  reg.state = calloc(size, sizeof(MAX_UNSIGNED));
 
-  if(!reg.node)
+  if(!(reg.state && reg.amplitude))
     quantum_error(QUANTUM_ENOMEM);
 
-  quantum_memman(size * sizeof(quantum_reg_node));
+  quantum_memman(size * (sizeof(COMPLEX_FLOAT) + sizeof(MAX_UNSIGNED)));
 
   /* Allocate the hash table */
 
@@ -82,8 +83,8 @@ quantum_matrix2qureg(quantum_matrix *m, int width)
     {
       if(m->t[i])
 	{
-	  reg.node[j].state = i;
-	  reg.node[j].amplitude = m->t[i];
+	  reg.state[j] = i;
+	  reg.amplitude[j] = m->t[i];
 	  j++;
 	}
     }
@@ -105,12 +106,13 @@ quantum_new_qureg(MAX_UNSIGNED initval, int width)
 
   /* Allocate memory for 1 base state */
 
-  reg.node = calloc(1, sizeof(quantum_reg_node));
+  reg.state = calloc(1, sizeof(MAX_UNSIGNED));
+  reg.amplitude = calloc(1, sizeof(COMPLEX_FLOAT));
 
-  if(!reg.node)
+  if(!(reg.state && reg.amplitude))
     quantum_error(QUANTUM_ENOMEM);
 
-  quantum_memman(sizeof(quantum_reg_node));
+  quantum_memman(sizeof(MAX_UNSIGNED) + sizeof(COMPLEX_FLOAT));
 
   /* Allocate the hash table */
 
@@ -123,8 +125,8 @@ quantum_new_qureg(MAX_UNSIGNED initval, int width)
 
   /* Initialize the quantum register */
   
-  reg.node[0].state = initval;
-  reg.node[0].amplitude = 1;
+  reg.state[0] = initval;
+  reg.amplitude[0] = 1;
 
   /* Initialize the PRNG */
 
@@ -158,12 +160,38 @@ quantum_new_qureg_size(int n, int width)
 
   /* Allocate memory for n basis states */
 
-  reg.node = calloc(n, sizeof(quantum_reg_node));
+  reg.amplitude = calloc(n, sizeof(COMPLEX_FLOAT));
+  reg.state = 0;
 
-  if(!reg.node)
+  if(!reg.amplitude)
     quantum_error(QUANTUM_ENOMEM);
 
-  quantum_memman(n*sizeof(quantum_reg_node));
+  quantum_memman(n*sizeof(COMPLEX_FLOAT));
+
+  return reg;
+}
+
+/* Returns an empty sparse quantum register of size N */
+
+quantum_reg
+quantum_new_qureg_sparse(int n, int width)
+{
+  quantum_reg reg;
+
+  reg.width = width;
+  reg.size = n;
+  reg.hashw = 0;
+  reg.hash = 0;
+
+  /* Allocate memory for n basis states */
+
+  reg.amplitude = calloc(n, sizeof(COMPLEX_FLOAT));
+  reg.state = calloc(n, sizeof(MAX_UNSIGNED));
+
+  if(!(reg.amplitude && reg.state))
+    quantum_error(QUANTUM_ENOMEM);
+
+  quantum_memman(n*(sizeof(COMPLEX_FLOAT)+sizeof(MAX_UNSIGNED)));
 
   return reg;
 }
@@ -179,7 +207,7 @@ quantum_qureg2matrix(quantum_reg reg)
   m = quantum_new_matrix(1, 1 << reg.width);
   
   for(i=0; i<reg.size; i++)
-    m.t[reg.node[i].state] = reg.node[i].amplitude;
+    m.t[reg.state[i]] = reg.amplitude[i];
 
   return m;
 }
@@ -201,9 +229,18 @@ quantum_delete_qureg(quantum_reg *reg)
 {
   if(reg->hashw && reg->hash)
     quantum_destroy_hash(reg);
-  free(reg->node);
-  quantum_memman(-reg->size * sizeof(quantum_reg_node));
-  reg->node = 0;
+
+  free(reg->amplitude);
+  quantum_memman(-reg->size * sizeof(COMPLEX_FLOAT));
+  reg->amplitude = 0;
+
+  if(reg->state)
+    {
+      free(reg->state);
+      quantum_memman(-reg->size * sizeof(MAX_UNSIGNED));
+      reg->state = 0;
+    }
+
 }
 
 /* Delete a quantum register but leave the hash table alive */
@@ -211,9 +248,16 @@ quantum_delete_qureg(quantum_reg *reg)
 void
 quantum_delete_qureg_hashpreserve(quantum_reg *reg)
 {
-  free(reg->node);
-  quantum_memman(-reg->size * sizeof(quantum_reg_node));
-  reg->node = 0;
+  free(reg->amplitude);
+  quantum_memman(-reg->size * sizeof(COMPLEX_FLOAT));
+  reg->amplitude = 0;
+
+  if(reg->state)
+    {
+      free(reg->state);
+      quantum_memman(-reg->size * sizeof(MAX_UNSIGNED));
+      reg->state = 0;
+    }
 }
 
 /* Copy the contents of src to dst */
@@ -225,12 +269,27 @@ quantum_copy_qureg(quantum_reg *src, quantum_reg *dst)
   
   /* Allocate memory for basis states */
 
-  dst->node = calloc(dst->size, sizeof(quantum_reg_node));
+  dst->amplitude = calloc(dst->size, sizeof(COMPLEX_FLOAT));
 
-  if(!dst->node)
+  if(!dst->amplitude)
     quantum_error(QUANTUM_ENOMEM);
 
-  quantum_memman(dst->size*sizeof(quantum_reg_node));
+  quantum_memman(dst->size*sizeof(COMPLEX_FLOAT));
+
+  memcpy(dst->amplitude, src->amplitude, src->size*sizeof(COMPLEX_FLOAT));
+
+  if(src->state)
+    {
+      dst->state = calloc(dst->size, sizeof(MAX_UNSIGNED));
+
+      if(!dst->state)
+	quantum_error(QUANTUM_ENOMEM);
+      
+      quantum_memman(dst->size*sizeof(MAX_UNSIGNED));
+
+      memcpy(dst->state, src->state, src->size*sizeof(MAX_UNSIGNED));
+
+    }
 
   /* Allocate the hash table */
 
@@ -244,8 +303,6 @@ quantum_copy_qureg(quantum_reg *src, quantum_reg *dst)
       quantum_memman((1 << dst->hashw) * sizeof(int));
     }
 
-  memcpy(dst->node, src->node, src->size*sizeof(quantum_reg_node));
-
 }
 
 /* Print the contents of a quantum register to stdout */
@@ -257,14 +314,14 @@ quantum_print_qureg(quantum_reg reg)
   
   for(i=0; i<reg.size; i++)
     {
-      printf("% f %+fi|%lli> (%e) (|", quantum_real(reg.node[i].amplitude),
-	     quantum_imag(reg.node[i].amplitude), reg.node[i].state, 
-	     quantum_prob_inline(reg.node[i].amplitude));
+      printf("% f %+fi|%lli> (%e) (|", quantum_real(reg.amplitude[i]),
+	     quantum_imag(reg.amplitude[i]), reg.state[i], 
+	     quantum_prob_inline(reg.amplitude[i]));
       for(j=reg.width-1;j>=0;j--)
 	{
 	  if(j % 4 == 3)
 	    printf(" ");
-	  printf("%i", ((((MAX_UNSIGNED) 1 << j) & reg.node[i].state) > 0));
+	  printf("%i", ((((MAX_UNSIGNED) 1 << j) & reg.state[i]) > 0));
 	}
 
       printf(">)\n");
@@ -282,7 +339,7 @@ quantum_print_expn(quantum_reg reg)
   
   for(i=0; i<reg.size; i++)
     {
-      printf("%i: %lli\n", i, reg.node[i].state - i * (1 << (reg.width / 2)));
+      printf("%i: %lli\n", i, reg.state[i] - i * (1 << (reg.width / 2)));
     }
 }
 
@@ -292,17 +349,15 @@ quantum_print_expn(quantum_reg reg)
 void
 quantum_addscratch(int bits, quantum_reg *reg)
 {
-  int i, oldwidth;
+  int i;
   MAX_UNSIGNED l;
   
-  oldwidth = reg->width;
-
   reg->width += bits;
 
   for(i=0; i<reg->size; i++)
     {
-      l = reg->node[i].state << bits;
-      reg->node[i].state = l;
+      l = reg->state[i] << bits;
+      reg->state[i] = l;
     }
 }
 
@@ -318,7 +373,7 @@ quantum_print_hash(quantum_reg reg)
     {
       if(i)
 	printf("%i: %i %llu\n", i, reg.hash[i]-1, 
-	       reg.node[reg.hash[i]-1].state);
+	       reg.state[reg.hash[i]-1]);
     }
 
 }
@@ -335,15 +390,15 @@ quantum_kronecker(quantum_reg *reg1, quantum_reg *reg2)
   reg.size = reg1->size*reg2->size;
   reg.hashw = reg.width + 2;
 
-
   /* allocate memory for the new basis states */
-  
-  reg.node = calloc(reg.size, sizeof(quantum_reg_node));
-  if(!reg.node) 
+
+  reg.amplitude = calloc(reg.size, sizeof(COMPLEX_FLOAT));
+  reg.state = calloc(reg.size, sizeof(MAX_UNSIGNED));
+
+  if(!(reg.state && reg.amplitude))
     quantum_error(QUANTUM_ENOMEM);
 
-  quantum_memman((reg.size)*sizeof(quantum_reg_node));
-
+  quantum_memman(reg.size * (sizeof(COMPLEX_FLOAT) + sizeof(MAX_UNSIGNED)));
 
   /* Allocate the hash table */
 
@@ -356,14 +411,13 @@ quantum_kronecker(quantum_reg *reg1, quantum_reg *reg2)
   for(i=0; i<reg1->size; i++)
     for(j=0; j<reg2->size; j++)
     {
-      /* printf("processing |%lli> x |%lli>\n", reg1->node[i].state, 
-	     reg2->node[j].state);
-         printf("%lli\n", (reg1->node[i].state) << reg2->width); */
+      /* printf("processing |%lli> x |%lli>\n", reg1->state[i], 
+	     reg2->state[j]);
+         printf("%lli\n", (reg1->state[i]) << reg2->width); */
 
-      reg.node[i*reg2->size+j].state = 	((reg1->node[i].state) << reg2->width)
-	| reg2->node[j].state;
-      reg.node[i*reg2->size+j].amplitude = 
-	reg1->node[i].amplitude * reg2->node[j].amplitude;
+      reg.state[i*reg2->size+j] = ((reg1->state[i]) << reg2->width) 
+	| reg2->state[j];
+      reg.amplitude[i*reg2->size+j] = reg1->amplitude[i] * reg2->amplitude[j];
     }
 
   return reg;
@@ -387,10 +441,10 @@ quantum_state_collapse(int pos, int value, quantum_reg reg)
   
   for(i=0;i<reg.size;i++)
     {
-      if(((reg.node[i].state & pos2) && value) 
-	 || (!(reg.node[i].state & pos2) && !value))
+      if(((reg.state[i] & pos2) && value) 
+	 || (!(reg.state[i] & pos2) && !value))
 	{
-	  d += quantum_prob_inline(reg.node[i].amplitude);
+	  d += quantum_prob_inline(reg.amplitude[i]);
 	  size++;
 	}
     }
@@ -399,12 +453,13 @@ quantum_state_collapse(int pos, int value, quantum_reg reg)
 
   out.width = reg.width-1;
   out.size = size;
-  out.node = calloc(size, sizeof(quantum_reg_node));
+  out.amplitude = calloc(size, sizeof(COMPLEX_FLOAT));
+  out.state = calloc(size, sizeof(MAX_UNSIGNED));
 
-  if(!out.node)
+  if(!(out.state && out.amplitude))
     quantum_error(QUANTUM_ENOMEM);
 
-  quantum_memman(size * sizeof(quantum_reg_node));
+  quantum_memman(size * (sizeof(COMPLEX_FLOAT) + sizeof(MAX_UNSIGNED)));
   out.hashw = reg.hashw;
   out.hash = reg.hash;
 
@@ -413,21 +468,21 @@ quantum_state_collapse(int pos, int value, quantum_reg reg)
 
   for(i=0, j=0; i<reg.size; i++)
     {
-      if(((reg.node[i].state & pos2) && value) 
-	 || (!(reg.node[i].state & pos2) && !value))
+      if(((reg.state[i] & pos2) && value) 
+	 || (!(reg.state[i] & pos2) && !value))
 	{
 	  for(k=0, rpat=0; k<pos; k++)
 	    rpat += (MAX_UNSIGNED) 1 << k;
 
-	  rpat &= reg.node[i].state;
+	  rpat &= reg.state[i];
 
 	  for(k=sizeof(MAX_UNSIGNED)*8-1, lpat=0; k>pos; k--)
 	    lpat += (MAX_UNSIGNED) 1 << k;
 
-	  lpat &= reg.node[i].state;
+	  lpat &= reg.state[i];
 
-	  out.node[j].state = (lpat >> 1) | rpat;
-	  out.node[j].amplitude = reg.node[i].amplitude * 1 / (float) sqrt(d);
+	  out.state[j] = (lpat >> 1) | rpat;
+	  out.amplitude[j] = reg.amplitude[i] * 1 / (float) sqrt(d);
 	
 	  j++;
 	}
@@ -450,14 +505,28 @@ quantum_dot_product(quantum_reg *reg1, quantum_reg *reg2)
   if(reg2->hashw)
     quantum_reconstruct_hash(reg2);
 
-  for(i=0; i<reg1->size; i++)
+  if(reg1->state)
     {
-      j = quantum_get_state(reg1->node[i].state, *reg2);
+      for(i=0; i<reg1->size; i++)
+	{
+	  j = quantum_get_state(reg1->state[i], *reg2);
 
-      if(j > -1) /* state exists in reg2 */
-	f += quantum_conj(reg1->node[i].amplitude) * reg2->node[j].amplitude;
+	  if(j > -1) /* state exists in reg2 */
+	    f += quantum_conj(reg1->amplitude[i]) * reg2->amplitude[j];
+	}
     }
 
+  else
+    {
+      for(i=0; i<reg1->size; i++)
+	{
+	  j = quantum_get_state(i, *reg2);
+
+	  if(j > -1) /* state exists in reg2 */
+	    f += quantum_conj(reg1->amplitude[i]) * reg2->amplitude[j];
+	}
+    }
+      
   return f;
 
 }
@@ -475,13 +544,21 @@ quantum_dot_product_noconj(quantum_reg *reg1, quantum_reg *reg2)
   if(reg2->hashw)
     quantum_reconstruct_hash(reg2);
 
-  for(i=0; i<reg1->size; i++)
+  if(!reg2->state)
     {
-      j = quantum_get_state(reg1->node[i].state, *reg2);
+      for(i=0; i<reg1->size; i++)
+	f += reg1->amplitude[i] * reg2->amplitude[reg1->state[i]];
+    }
 
-      if(j > -1) /* state exists in reg2 */
-	f += reg1->node[i].amplitude * reg2->node[j].amplitude;
-      
+  else
+    {
+      for(i=0; i<reg1->size; i++)
+	{
+	  j = quantum_get_state(reg1->state[i], *reg2);
+
+	  if(j > -1) /* state exists in reg2 */
+	    f += reg1->amplitude[i] * reg2->amplitude[j];
+	}
     }
 
   return f;
@@ -510,32 +587,47 @@ quantum_vectoradd(quantum_reg *reg1, quantum_reg *reg2)
 
       for(i=0; i<reg2->size; i++)
 	{
-	  if(quantum_get_state(reg2->node[i].state, *reg1) == -1)
+	  if(quantum_get_state(reg2->state[i], *reg1) == -1)
 	    addsize++;
 	}
     }
 
-  reg.size += addsize;
-  reg.node = realloc(reg.node, (reg.size)*sizeof(quantum_reg_node));
-  if(!reg.node)
-    quantum_error(QUANTUM_ENOMEM);
+  if(addsize)
+    {
+      reg.size += addsize;
 
-  quantum_memman(addsize*sizeof(quantum_reg_node));
+      reg.amplitude = realloc(reg.amplitude, reg.size*sizeof(COMPLEX_FLOAT));
+      reg.state = realloc(reg.state, reg.size*sizeof(MAX_UNSIGNED));
+
+      if(!(reg.state && reg.amplitude))
+	quantum_error(QUANTUM_ENOMEM);
+
+      quantum_memman(addsize * (sizeof(COMPLEX_FLOAT) + sizeof(MAX_UNSIGNED)));
+    }
 
   k = reg1->size;
 
-  for(i=0; i<reg2->size; i++)
+  if(!reg2->state)
     {
-      j = quantum_get_state(reg2->node[i].state, *reg1);
+      for(i=0; i<reg2->size; i++)
+	reg.amplitude[i] += reg2->amplitude[i];
+    }
 
-      if(j >= 0)
-	reg.node[j].amplitude += reg2->node[i].amplitude;
-
-      else
+  else
+    {
+      for(i=0; i<reg2->size; i++)
 	{
-	  reg.node[k].state = reg2->node[i].state;
-	  reg.node[k].amplitude = reg2->node[i].amplitude;
-	  k++;
+	  j = quantum_get_state(reg2->state[i], *reg1);
+	  
+	  if(j >= 0)
+	    reg.amplitude[j] += reg2->amplitude[i];
+
+	  else
+	    {
+	      reg.state[k] = reg2->state[i];
+	      reg.amplitude[k] = reg2->amplitude[i];
+	      k++;
+	    }
 	}
     }
   
@@ -559,41 +651,55 @@ quantum_vectoradd_inplace(quantum_reg *reg1, quantum_reg *reg2)
 
       for(i=0; i<reg2->size; i++)
 	{
-	  if(quantum_get_state(reg2->node[i].state, *reg1) == -1)
+	  if(quantum_get_state(reg2->state[i], *reg1) == -1)
 	    addsize++;
 	}
     }
 
-  /* Allocate memory for basis states */
+  if(addsize)
+    {
 
-  reg1->node = realloc(reg1->node, (reg1->size+addsize) 
-		       * sizeof(quantum_reg_node));
+      /* Allocate memory for basis states */
 
-  if(!reg1->node)
-    quantum_error(QUANTUM_ENOMEM);
+      reg1->amplitude = realloc(reg1->amplitude, 
+				(reg1->size+addsize)*sizeof(COMPLEX_FLOAT));
+      reg1->state = realloc(reg1->state, (reg1->size+addsize)
+			    *sizeof(MAX_UNSIGNED));
 
-  quantum_memman(addsize*sizeof(quantum_reg_node));
+      if(!(reg1->state && reg1->amplitude))
+	quantum_error(QUANTUM_ENOMEM);
 
-  /* Allocate the hash table */
+      quantum_memman(addsize * (sizeof(COMPLEX_FLOAT) + sizeof(MAX_UNSIGNED)));
+
+    }
 
   k = reg1->size;
 
-  for(i=0; i<reg2->size; i++)
+  if(!reg2->state)
     {
-      j = quantum_get_state(reg2->node[i].state, *reg1);
-
-      if(j >= 0)
-	reg1->node[j].amplitude += reg2->node[i].amplitude;
-
-      else
-	{
-	  reg1->node[k].state = reg2->node[i].state;
-	  reg1->node[k].amplitude = reg2->node[i].amplitude;
-	  k++;
-	}
+      for(i=0; i<reg2->size; i++)
+	reg1->amplitude[i] += reg2->amplitude[i];
     }
 
-  reg1->size += addsize;
+  else
+    {
+      for(i=0; i<reg2->size; i++)
+	{
+	  j = quantum_get_state(reg2->state[i], *reg1);
+
+	  if(j >= 0)
+	    reg1->amplitude[j] += reg2->amplitude[i];
+
+	  else
+	    {
+	      reg1->state[k] = reg2->state[i];
+	      reg1->amplitude[k] = reg2->amplitude[i];
+	      k++;
+	    }
+	}
+
+      reg1->size += addsize;
+    }
       
 }
 
@@ -607,30 +713,45 @@ quantum_reg
 quantum_matrix_qureg(quantum_reg A(MAX_UNSIGNED, double), double t,
 		     quantum_reg *reg, int flags)
 {
-  MAX_UNSIGNED i;
+  int i;
   quantum_reg reg2;
   quantum_reg tmp;
 
   reg2.width = reg->width;
-  reg2.size = 1 << reg2.width;
+  reg2.size = reg->size;
   reg2.hashw = 0;
   reg2.hash = 0;
 
-  reg2.node = calloc(reg2.size, sizeof(quantum_reg_node));
-  if(!reg2.node)
+  reg2.amplitude = calloc(reg2.size, sizeof(COMPLEX_FLOAT));
+  reg2.state = 0;
+
+  if(!reg2.amplitude)
     quantum_error(QUANTUM_ENOMEM);
 
-  quantum_memman(reg2.size*sizeof(quantum_reg_node));
+  quantum_memman(reg2.size * sizeof(COMPLEX_FLOAT));
 
-  for(i=0; i<(1<<reg->width); i++)
+  if(reg->state)
     {
-      reg2.node[i].state = i;
+      reg2.state = calloc(reg2.size, sizeof(MAX_UNSIGNED));
+
+      if(!reg2.state)
+	quantum_error(QUANTUM_ENOMEM);
+
+      quantum_memman(reg2.size * sizeof(MAX_UNSIGNED));
+    }
+
+#ifdef _OPENMP
+  #pragma omp parallel for private (tmp)
+#endif
+  for(i=0; i<reg->size; i++)
+    {
+      if(reg2.state)
+	reg2.state[i] = i;
       tmp = A(i, t);
-      reg2.node[i].amplitude = quantum_dot_product_noconj(&tmp, reg);
+      reg2.amplitude[i] = quantum_dot_product_noconj(&tmp, reg);
       if(!(flags & 1))
 	quantum_delete_qureg(&tmp);
     }
-  
  
   return reg2;
 
@@ -645,9 +766,9 @@ quantum_mvmult(quantum_reg *y, quantum_matrix A, quantum_reg *x)
 
   for(i=0; i<A.cols; i++)
     {
-      y->node[i].amplitude = 0;
+      y->amplitude[i] = 0;
       for(j=0; j<A.cols; j++)
-	y->node[i].amplitude += M(A, j, i)*x->node[j].amplitude;
+	y->amplitude[i] += M(A, j, i)*x->amplitude[j];
     }
 } 
 
@@ -662,7 +783,7 @@ quantum_scalar_qureg(COMPLEX_FLOAT r, quantum_reg *reg)
   int i;
   
   for(i=0; i<reg->size; i++)
-      reg->node[i].amplitude *= r;
+      reg->amplitude[i] *= r;
 }
 
 /* Print the time evolution matrix for a series of gates */
@@ -681,7 +802,7 @@ quantum_print_timeop(int width, void f(quantum_reg *))
       tmp = quantum_new_qureg(i, width);
       f(&tmp);
       for(j=0; j<tmp.size; j++)
-	M(m, tmp.node[j].state, i) = tmp.node[j].amplitude;
+	M(m, tmp.state[j], i) = tmp.amplitude[j];
 
       quantum_delete_qureg(&tmp);
 	  
@@ -692,3 +813,18 @@ quantum_print_timeop(int width, void f(quantum_reg *))
   quantum_delete_matrix(&m);
   
 }
+
+/* Normalize a quantum register */
+
+void
+quantum_normalize(quantum_reg *reg)
+{
+  int i;
+  double r = 0;
+
+  for(i=0; i<reg->size; i++)
+    r += quantum_prob(reg->amplitude[i]);
+
+  quantum_scalar_qureg(1./sqrt(r), reg);
+
+}