mirror of
https://github.com/libquantum/libquantum.git
synced 2025-10-03 16:51:37 +00:00
updated libquantum 0.1.0 source files
This commit is contained in:
libquantum
71
INSTALL
Normal file
71
INSTALL
Normal file
@@ -0,0 +1,71 @@
|
|||||||
|
libquantum 0.1.0 installation guide
|
||||||
|
-----------------------------------
|
||||||
|
|
||||||
|
Contents:
|
||||||
|
|
||||||
|
0. Requirements
|
||||||
|
1. Configure and make
|
||||||
|
2. Installation of the library
|
||||||
|
3. Write your own programs
|
||||||
|
|
||||||
|
|
||||||
|
0. Requirements
|
||||||
|
---------------
|
||||||
|
|
||||||
|
libquantum needs a C compiler with complex number support (C99
|
||||||
|
prefered). A recent gcc (>=2.9.5) will do the job. Furthermore, the
|
||||||
|
host must support 64-bit integers, even if it is not a 64-bit machine.
|
||||||
|
|
||||||
|
If you encounter any difficulties while building, installing or using
|
||||||
|
libquantum, we would like to hear from you. Just send a mail to
|
||||||
|
libquantum@enyo.de.
|
||||||
|
|
||||||
|
|
||||||
|
1. Configure and Make
|
||||||
|
---------------------
|
||||||
|
|
||||||
|
As libquantum was created using autoconf and libtool, this step should
|
||||||
|
not be a major problem. Simply extract the tarball to a directory:
|
||||||
|
|
||||||
|
tar xzvf libquantum-0.1.0.tar.gz
|
||||||
|
|
||||||
|
Next, run the configure script:
|
||||||
|
|
||||||
|
./configure
|
||||||
|
|
||||||
|
Now you can build the beast:
|
||||||
|
|
||||||
|
make
|
||||||
|
|
||||||
|
By now, you can create a sample program which implements Shor's
|
||||||
|
factoring algorithm:
|
||||||
|
|
||||||
|
make shor
|
||||||
|
|
||||||
|
The number to be factored is given on the command line as the first
|
||||||
|
parameter. To factor 15, simply type:
|
||||||
|
|
||||||
|
./shor 15
|
||||||
|
|
||||||
|
|
||||||
|
2. Installation of the library
|
||||||
|
------------------------------
|
||||||
|
|
||||||
|
For this step you will need to have superuser privileges. Just type
|
||||||
|
|
||||||
|
make install
|
||||||
|
|
||||||
|
to get libquantum installed into the default directory, which is
|
||||||
|
usually /usr/local/bin. Note that on some systems this directories is
|
||||||
|
not in the standard search path. Take a look at the output of the last
|
||||||
|
command to get some advice on how to deal with this.
|
||||||
|
|
||||||
|
3. Writing your own programs
|
||||||
|
----------------------------
|
||||||
|
|
||||||
|
You can use libquantum as any other C library. Just #include
|
||||||
|
<quantum.h> in your source file and link the library into your program
|
||||||
|
with the linker flag -lquantum.
|
||||||
|
|
||||||
|
For a detailed guide on programming with libquantum take a look at
|
||||||
|
http://www.enyo.de/libquantum.
|
||||||
126
Makefile.in
Normal file
126
Makefile.in
Normal file
@@ -0,0 +1,126 @@
|
|||||||
|
# Makefile: Build libquantum
|
||||||
|
#
|
||||||
|
# Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
#
|
||||||
|
# This file is part of libquantum
|
||||||
|
#
|
||||||
|
# libquantum is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published
|
||||||
|
# by the Free Software Foundation; either version 2 of the License,
|
||||||
|
# or (at your option) any later version.
|
||||||
|
#
|
||||||
|
# libquantum is distributed in the hope that it will be useful, but
|
||||||
|
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
# General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with libquantum; if not, write to the Free Software
|
||||||
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
# USA
|
||||||
|
|
||||||
|
# Every Makefile should contain this line
|
||||||
|
|
||||||
|
SHELL=/bin/sh
|
||||||
|
|
||||||
|
# Target directory prefix
|
||||||
|
|
||||||
|
PREFIX=@prefix@
|
||||||
|
|
||||||
|
# Other directories
|
||||||
|
|
||||||
|
LIBDIR=${PREFIX}/lib
|
||||||
|
INCLUDEDIR=${PREFIX}/include
|
||||||
|
top_builddir=.
|
||||||
|
|
||||||
|
# Release information
|
||||||
|
|
||||||
|
MAJOR=0
|
||||||
|
MINOR=1
|
||||||
|
RELEASE=0
|
||||||
|
|
||||||
|
# Tools needed to build libquantum
|
||||||
|
|
||||||
|
CC=@CC@
|
||||||
|
INSTALL=@INSTALL@
|
||||||
|
LIBTOOL=@LIBTOOL@
|
||||||
|
|
||||||
|
# Flags passed to C compiler
|
||||||
|
|
||||||
|
CFLAGS=@CFLAGS@
|
||||||
|
LDFLAGS=-rpath $(LIBDIR) -version-info 1:0:1
|
||||||
|
|
||||||
|
# Dependencies
|
||||||
|
|
||||||
|
all: libquantum.la
|
||||||
|
|
||||||
|
libquantum.la: complex.lo measure.lo matrix.lo gates.lo qft.lo classic.lo\
|
||||||
|
qureg.lo decoherence.lo oaddn.lo omuln.lo expn.lo Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(LDFLAGS) -o libquantum.la complex.lo measure.lo\
|
||||||
|
matrix.lo gates.lo oaddn.lo omuln.lo expn.lo qft.lo classic.lo\
|
||||||
|
qureg.lo decoherence.lo -lm
|
||||||
|
|
||||||
|
complex.lo: complex.c complex.h Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c complex.c
|
||||||
|
|
||||||
|
measure.lo: measure.c measure.h matrix.h qureg.h config.h Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c measure.c
|
||||||
|
|
||||||
|
matrix.lo: matrix.c matrix.h complex.h Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c matrix.c
|
||||||
|
|
||||||
|
gates.lo: gates.c gates.h matrix.h defs.h qureg.h Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c gates.c
|
||||||
|
|
||||||
|
oaddn.lo: oaddn.c matrix.h defs.h gates.h qureg.h Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c oaddn.c
|
||||||
|
|
||||||
|
omuln.lo: omuln.c matrix.h gates.h oaddn.h defs.h qureg.h Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c omuln.c
|
||||||
|
|
||||||
|
expn.lo: expn.c expn.h matrix.h gates.h oaddn.h omuln.h qureg.h Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c expn.c
|
||||||
|
|
||||||
|
qft.lo: qft.c qft.h matrix.h gates.h qureg.h Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c qft.c
|
||||||
|
|
||||||
|
classic.lo: classic.c classic.h Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c classic.c
|
||||||
|
|
||||||
|
qureg.lo: qureg.c qureg.h matrix.h config.h complex.h Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c qureg.c
|
||||||
|
|
||||||
|
decoherence.lo: decoherence.c decoherence.h measure.h gates.h qureg.h config.h\
|
||||||
|
Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -c decoherence.c
|
||||||
|
|
||||||
|
# Bring this savage back home
|
||||||
|
|
||||||
|
install: libquantum.la
|
||||||
|
$(LIBTOOL) $(INSTALL) -m 0644 libquantum.la $(LIBDIR)
|
||||||
|
$(INSTALL) -m 0644 quantum.h $(INCLUDEDIR)
|
||||||
|
|
||||||
|
# Build a demo showing Shor's factoring algorithm
|
||||||
|
|
||||||
|
shor: libquantum.la shor.c Makefile
|
||||||
|
$(LIBTOOL) $(CC) $(CFLAGS) -o shor shor.c -I./ -lquantum -lm
|
||||||
|
|
||||||
|
# Make everything neat and tidy
|
||||||
|
|
||||||
|
clean:
|
||||||
|
-rm -rf .libs
|
||||||
|
rm shor libquantum.la *.lo *.o
|
||||||
|
|
||||||
|
distclean:
|
||||||
|
-rm -rf .libs
|
||||||
|
rm shor *.lo *.o config.h quantum.h config.status config.log\
|
||||||
|
libquantum.la
|
||||||
|
|
||||||
|
dist:
|
||||||
|
mkdir libquantum-$(MAJOR).$(MINOR).$(RELEASE)
|
||||||
|
cp *.c *.h quantum.h.in Makefile.in config.h.in configure COPYING\
|
||||||
|
install-sh ltmain.sh config.sub config.guess README INSTALL\
|
||||||
|
libquantum-$(MAJOR).$(MINOR).$(RELEASE)
|
||||||
|
tar czf libquantum-$(MAJOR).$(MINOR).$(RELEASE).tar.gz\
|
||||||
|
libquantum-$(MAJOR).$(MINOR).$(RELEASE)/
|
||||||
|
rm -rf libquantum-$(MAJOR).$(MINOR).$(RELEASE)
|
||||||
21
README
Normal file
21
README
Normal file
@@ -0,0 +1,21 @@
|
|||||||
|
libquantum 0.1.0 README file
|
||||||
|
----------------------------
|
||||||
|
|
||||||
|
libquantum is a C library for quantum computing. It provides quantum
|
||||||
|
registers, unitary operations and measurement functions. The main goal
|
||||||
|
is a physically precise simulation of a quantum computer with high
|
||||||
|
performance.
|
||||||
|
|
||||||
|
An implementation of Shor's factoring algorithm is included with this
|
||||||
|
release.
|
||||||
|
|
||||||
|
See the file INSTALL for help on the installation.
|
||||||
|
|
||||||
|
guardian is distributed under the terms of the GNU General Public
|
||||||
|
License (GPL), which is located in the file COPYING.
|
||||||
|
|
||||||
|
Send inquiries, comments, bug reports, suggestions, patches, etc. to:
|
||||||
|
libquantum@enyo.de
|
||||||
|
|
||||||
|
See also the guardian website:
|
||||||
|
http://www.enyo.de/libquantum
|
||||||
113
classic.c
Normal file
113
classic.c
Normal file
@@ -0,0 +1,113 @@
|
|||||||
|
/* classic.c: Classic operations used in libquantum
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <math.h>
|
||||||
|
|
||||||
|
/* Calculate A^B with A and B as integers */
|
||||||
|
|
||||||
|
int
|
||||||
|
quantum_ipow(int a, int b)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
int r=1;
|
||||||
|
|
||||||
|
for(i=0; i<b ;i++)
|
||||||
|
r*=a;
|
||||||
|
|
||||||
|
return r;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Calculate the greatest common divisor with Euclid's algorithm */
|
||||||
|
|
||||||
|
int
|
||||||
|
quantum_gcd(int u, int v)
|
||||||
|
{
|
||||||
|
int r;
|
||||||
|
|
||||||
|
while(v)
|
||||||
|
{
|
||||||
|
r = u % v;
|
||||||
|
u = v;
|
||||||
|
v = r;
|
||||||
|
}
|
||||||
|
return u;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Fractional approximation of a decimal value */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_frac_approx(int *a, int *b, int width)
|
||||||
|
{
|
||||||
|
float f = (float) *a / *b;
|
||||||
|
float g=f;
|
||||||
|
int i, num2=0, den2=1, num1=1, den1=0, num=0, den=0;
|
||||||
|
|
||||||
|
do
|
||||||
|
{
|
||||||
|
i = (int) (g+0.000005);
|
||||||
|
|
||||||
|
g -= i-0.000005;
|
||||||
|
g = 1.0/g;
|
||||||
|
|
||||||
|
if (i * den1 + den2 > 1<<width)
|
||||||
|
break;
|
||||||
|
|
||||||
|
num = i * num1 + num2;
|
||||||
|
den = i * den1 + den2;
|
||||||
|
|
||||||
|
num2 = num1;
|
||||||
|
den2 = den1;
|
||||||
|
num1 = num;
|
||||||
|
den1 = den;
|
||||||
|
|
||||||
|
} while(fabsf(((float) num / den) - f) > 1.0 / (2 * (1 << width)));
|
||||||
|
|
||||||
|
*a = num;
|
||||||
|
*b = den;
|
||||||
|
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Calculates the number of qubits required to store N */
|
||||||
|
|
||||||
|
int
|
||||||
|
quantum_getwidth(int n)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=1; 1<<i<n; i++);
|
||||||
|
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Calculate the inverse modulus of N and C */
|
||||||
|
|
||||||
|
int
|
||||||
|
quantum_inverse_mod(int n, int c)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=1; (i*c)%n!=1; i++);
|
||||||
|
|
||||||
|
return i;
|
||||||
|
}
|
||||||
36
classic.h
Normal file
36
classic.h
Normal file
@@ -0,0 +1,36 @@
|
|||||||
|
/* classic.h: Declarations for classic.c
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __CLASSIC_H
|
||||||
|
|
||||||
|
#define __CLASSIC_H
|
||||||
|
|
||||||
|
extern int quantum_ipow(int a, int b);
|
||||||
|
extern int quantum_gcd(int u, int v);
|
||||||
|
|
||||||
|
extern void quantum_frac_approx(int *a, int *b, int width);
|
||||||
|
extern int quantum_getwidth(int n);
|
||||||
|
|
||||||
|
extern int quantum_inverse_mod(int n, int c);
|
||||||
|
|
||||||
|
#endif
|
||||||
73
complex.c
Normal file
73
complex.c
Normal file
@@ -0,0 +1,73 @@
|
|||||||
|
/* complex.c: Complex number functions
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <math.h>
|
||||||
|
|
||||||
|
#include "complex.h"
|
||||||
|
#include "config.h"
|
||||||
|
|
||||||
|
/* Return the real part of a complex number */
|
||||||
|
|
||||||
|
float
|
||||||
|
quantum_real(COMPLEX_FLOAT a)
|
||||||
|
{
|
||||||
|
float *p = (float *) &a;
|
||||||
|
return p[0];
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Return the imaginary part of a complex number */
|
||||||
|
|
||||||
|
float
|
||||||
|
quantum_imag(COMPLEX_FLOAT a)
|
||||||
|
{
|
||||||
|
float *p = (float *) &a;
|
||||||
|
return p[1];
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Return the complex conjugate of a complex number */
|
||||||
|
|
||||||
|
COMPLEX_FLOAT
|
||||||
|
quantum_conj(COMPLEX_FLOAT a)
|
||||||
|
{
|
||||||
|
float r, i;
|
||||||
|
|
||||||
|
r = quantum_real(a);
|
||||||
|
i = quantum_imag(a);
|
||||||
|
|
||||||
|
return r - IMAGINARY * i;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Calculate the square of a complex number (i.e. the probability) */
|
||||||
|
|
||||||
|
float
|
||||||
|
quantum_prob(COMPLEX_FLOAT a)
|
||||||
|
{
|
||||||
|
return (float) (a * quantum_conj(a));
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Calculate e^(i * phi) */
|
||||||
|
|
||||||
|
COMPLEX_FLOAT quantum_cexp(float phi)
|
||||||
|
{
|
||||||
|
return cos(phi) + IMAGINARY * sin(phi);
|
||||||
|
}
|
||||||
37
complex.h
Normal file
37
complex.h
Normal file
@@ -0,0 +1,37 @@
|
|||||||
|
/* complex.h: Declarations for complex.c
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __COMPLEX_H
|
||||||
|
|
||||||
|
#define __COMPLEX_H
|
||||||
|
|
||||||
|
#include "config.h"
|
||||||
|
|
||||||
|
extern float quantum_real(COMPLEX_FLOAT a);
|
||||||
|
extern float quantum_imag(COMPLEX_FLOAT a);
|
||||||
|
extern COMPLEX_FLOAT quantum_conj(COMPLEX_FLOAT a);
|
||||||
|
|
||||||
|
extern float quantum_prob (COMPLEX_FLOAT a);
|
||||||
|
extern COMPLEX_FLOAT quantum_cexp(float phi);
|
||||||
|
|
||||||
|
#endif
|
||||||
1325
config.guess
vendored
Executable file
1325
config.guess
vendored
Executable file
File diff suppressed because it is too large
Load Diff
65
config.h.in
Normal file
65
config.h.in
Normal file
@@ -0,0 +1,65 @@
|
|||||||
|
/* config.h.in. Generated from configure.in by autoheader. */
|
||||||
|
|
||||||
|
/* Complex data type */
|
||||||
|
#undef COMPLEX_FLOAT
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <fcntl.h> header file. */
|
||||||
|
#undef HAVE_FCNTL_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <inttypes.h> header file. */
|
||||||
|
#undef HAVE_INTTYPES_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the `m' library (-lm). */
|
||||||
|
#undef HAVE_LIBM
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <memory.h> header file. */
|
||||||
|
#undef HAVE_MEMORY_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <stdint.h> header file. */
|
||||||
|
#undef HAVE_STDINT_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <stdlib.h> header file. */
|
||||||
|
#undef HAVE_STDLIB_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <strings.h> header file. */
|
||||||
|
#undef HAVE_STRINGS_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <string.h> header file. */
|
||||||
|
#undef HAVE_STRING_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <sys/stat.h> header file. */
|
||||||
|
#undef HAVE_SYS_STAT_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <sys/types.h> header file. */
|
||||||
|
#undef HAVE_SYS_TYPES_H
|
||||||
|
|
||||||
|
/* Define to 1 if you have the <unistd.h> header file. */
|
||||||
|
#undef HAVE_UNISTD_H
|
||||||
|
|
||||||
|
/* Imaginary unit */
|
||||||
|
#undef IMAGINARY
|
||||||
|
|
||||||
|
/* Integer type for quantum registers */
|
||||||
|
#undef MAX_UNSIGNED
|
||||||
|
|
||||||
|
/* Define to the address where bug reports for this package should be sent. */
|
||||||
|
#undef PACKAGE_BUGREPORT
|
||||||
|
|
||||||
|
/* Define to the full name of this package. */
|
||||||
|
#undef PACKAGE_NAME
|
||||||
|
|
||||||
|
/* Define to the full name and version of this package. */
|
||||||
|
#undef PACKAGE_STRING
|
||||||
|
|
||||||
|
/* Define to the one symbol short name of this package. */
|
||||||
|
#undef PACKAGE_TARNAME
|
||||||
|
|
||||||
|
/* Define to the version of this package. */
|
||||||
|
#undef PACKAGE_VERSION
|
||||||
|
|
||||||
|
/* Define to 1 if you have the ANSI C header files. */
|
||||||
|
#undef STDC_HEADERS
|
||||||
|
|
||||||
|
/* Define as `__inline' if that's what the C compiler calls it, or to nothing
|
||||||
|
if it is not supported. */
|
||||||
|
#undef inline
|
||||||
1460
config.sub
vendored
Executable file
1460
config.sub
vendored
Executable file
File diff suppressed because it is too large
Load Diff
104
decoherence.c
Normal file
104
decoherence.c
Normal file
@@ -0,0 +1,104 @@
|
|||||||
|
/* decoherence.c: Simulation of decoherence effects
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <math.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
|
||||||
|
#include "measure.h"
|
||||||
|
#include "qureg.h"
|
||||||
|
#include "gates.h"
|
||||||
|
#include "complex.h"
|
||||||
|
|
||||||
|
/* Status of the decoherence simulation. Non-zero means enabled and
|
||||||
|
decoherence effects will be simulated. */
|
||||||
|
|
||||||
|
int status = 0;
|
||||||
|
|
||||||
|
/* Decoherence parameter. The higher the value, the greater the
|
||||||
|
decoherence impact. */
|
||||||
|
|
||||||
|
float lambda = 0;
|
||||||
|
|
||||||
|
/* Initialize the decoherence simulation and set the decoherence
|
||||||
|
parameter. */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_set_decoherence(float l)
|
||||||
|
{
|
||||||
|
if(l)
|
||||||
|
{
|
||||||
|
status = 1;
|
||||||
|
lambda = l;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
status = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Perform the actual decoherence of a quantum register for a single
|
||||||
|
step of time. This is done by applying a phase shift by a normal
|
||||||
|
distributed angle with the variance LAMBDA. */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_decohere(quantum_reg *reg)
|
||||||
|
{
|
||||||
|
float u, v, s, x;
|
||||||
|
COMPLEX_FLOAT c0, c1;
|
||||||
|
int i, j;
|
||||||
|
|
||||||
|
/* Increase the gate counter */
|
||||||
|
|
||||||
|
quantum_gate_counter(1);
|
||||||
|
|
||||||
|
if(status)
|
||||||
|
{
|
||||||
|
for(j=0; j<reg->width; j++)
|
||||||
|
{
|
||||||
|
/* Generate a normal distributed random number */
|
||||||
|
|
||||||
|
do {
|
||||||
|
u = 2 * quantum_frand() - 1;
|
||||||
|
v = 2 * quantum_frand() - 1;
|
||||||
|
s = u * u + v * v;
|
||||||
|
} while (s >= 1);
|
||||||
|
|
||||||
|
x = u * sqrt(-2 * log(s) / s);
|
||||||
|
|
||||||
|
x *= sqrt(2 * lambda);
|
||||||
|
|
||||||
|
/* Apply the phase shift gate for decoherence simulation */
|
||||||
|
|
||||||
|
c0 = quantum_cexp(-x / 2);
|
||||||
|
c1 = quantum_cexp(x / 2);
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << j))
|
||||||
|
reg->node[i].amplitude *= c1;
|
||||||
|
|
||||||
|
else
|
||||||
|
reg->node[i].amplitude *= c0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
32
decoherence.h
Normal file
32
decoherence.h
Normal file
@@ -0,0 +1,32 @@
|
|||||||
|
/* decoherence.h: Declarations for decoherence.c
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __DECOHERENCE_H
|
||||||
|
|
||||||
|
#define __DECOHERENCE_H
|
||||||
|
|
||||||
|
extern void quantum_set_decoherence(float lambda);
|
||||||
|
|
||||||
|
extern void quantum_decohere(quantum_reg *reg);
|
||||||
|
|
||||||
|
#endif
|
||||||
34
defs.h
Normal file
34
defs.h
Normal file
@@ -0,0 +1,34 @@
|
|||||||
|
/* defs.h: Global definitions
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __DEFS_H
|
||||||
|
|
||||||
|
#define __DEFS_H
|
||||||
|
|
||||||
|
#define pi 3.141592654
|
||||||
|
|
||||||
|
#define byte unsigned char
|
||||||
|
|
||||||
|
#define num_regs 4
|
||||||
|
|
||||||
|
#endif
|
||||||
28
expn.c
Normal file
28
expn.c
Normal file
@@ -0,0 +1,28 @@
|
|||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <math.h>
|
||||||
|
|
||||||
|
#include "defs.h"
|
||||||
|
#include "gates.h"
|
||||||
|
#include "omuln.h"
|
||||||
|
#include "qureg.h"
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_exp_mod_n(int N, int x, int width_input, int width, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
|
||||||
|
int i, j, f;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
quantum_sigma_x(2*width+2, reg);
|
||||||
|
for (i=1; i<=width_input;i++){
|
||||||
|
f=x%N; //compute
|
||||||
|
for (j=1;j<i;j++)
|
||||||
|
{
|
||||||
|
f*=f; //x^2^(i-1)
|
||||||
|
f= f%N;
|
||||||
|
}
|
||||||
|
mul_mod_n(N,f,3*width+1+i, width, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
9
expn.h
Normal file
9
expn.h
Normal file
@@ -0,0 +1,9 @@
|
|||||||
|
#ifndef __EXPN_H
|
||||||
|
|
||||||
|
#define __EXPN_H
|
||||||
|
|
||||||
|
#include "qureg.h"
|
||||||
|
|
||||||
|
extern void quantum_exp_mod_n(int, int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
#endif
|
||||||
484
gates.c
Normal file
484
gates.c
Normal file
@@ -0,0 +1,484 @@
|
|||||||
|
/* gates.c: Basic gates for quantum register manipulation
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <math.h>
|
||||||
|
|
||||||
|
#include "matrix.h"
|
||||||
|
#include "defs.h"
|
||||||
|
#include "complex.h"
|
||||||
|
#include "qureg.h"
|
||||||
|
#include "decoherence.h"
|
||||||
|
|
||||||
|
/* Apply a controlled-not gate */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_cnot(int control, int target, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
/* Flip the target bit of a base state if the control bit is set */
|
||||||
|
|
||||||
|
if((reg->node[i].state & ((MAX_UNSIGNED) 1 << control)))
|
||||||
|
reg->node[i].state ^= ((MAX_UNSIGNED) 1 << target);
|
||||||
|
}
|
||||||
|
quantum_decohere(reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply a toffoli (or controlled-controlled-not) gate */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_toffoli(int control1, int control2, int target, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
/* Flip the target bit of a base state if both control bits are
|
||||||
|
set */
|
||||||
|
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << control1))
|
||||||
|
{
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << control2))
|
||||||
|
{
|
||||||
|
reg->node[i].state ^= ((MAX_UNSIGNED) 1 << target);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
quantum_decohere(reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply a sigma_x (or not) gate */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_sigma_x(int target, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
/* Flip the target bit of each base state */
|
||||||
|
|
||||||
|
reg->node[i].state ^= ((MAX_UNSIGNED) 1 << target);
|
||||||
|
}
|
||||||
|
quantum_decohere(reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply a sigma_y gate */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_sigma_y(int target, int width, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=0; i<reg->size;i++)
|
||||||
|
{
|
||||||
|
/* Flip the target bit of each base state and multiply with
|
||||||
|
+/- i */
|
||||||
|
|
||||||
|
reg->node[i].state ^= ((MAX_UNSIGNED) 1 << target);
|
||||||
|
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << target))
|
||||||
|
reg->node[i].amplitude *= IMAGINARY;
|
||||||
|
else
|
||||||
|
reg->node[i].amplitude *= -IMAGINARY;
|
||||||
|
}
|
||||||
|
|
||||||
|
quantum_decohere(reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply a sigma_y gate */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_sigma_z(int target, int width, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
/* Multiply with -1 if the target bit is set */
|
||||||
|
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << target))
|
||||||
|
reg->node[i].amplitude *= -1;
|
||||||
|
}
|
||||||
|
quantum_decohere(reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Swap the first WIDTH bits of the quantum register. This is done
|
||||||
|
classically by renaming the bits. */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_swaptheleads(int width, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i, j;
|
||||||
|
int pat1, pat2;
|
||||||
|
MAX_UNSIGNED l;
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
/* calculate left bit pattern */
|
||||||
|
|
||||||
|
pat1 = reg->node[i].state % ((MAX_UNSIGNED) 1 << width);
|
||||||
|
|
||||||
|
/*calculate right but pattern */
|
||||||
|
|
||||||
|
pat2 = 0;
|
||||||
|
|
||||||
|
for(j=0; j<width; j++)
|
||||||
|
pat2 += reg->node[i].state & ((MAX_UNSIGNED) 1 << (width + j));
|
||||||
|
|
||||||
|
/* construct the new base state */
|
||||||
|
|
||||||
|
l = reg->node[i].state - (pat1 + pat2);
|
||||||
|
l += (pat1 << width);
|
||||||
|
l += (pat2 >> width);
|
||||||
|
reg->node[i].state = l;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Swap WIDTH bits starting at WIDTH and 2*WIDTH+2 controlled by
|
||||||
|
CONTROL */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_swaptheleads_omuln_controlled(int control, int width, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=0; i<width; i++)
|
||||||
|
{
|
||||||
|
quantum_toffoli(control, width+i, 2*width+i+2, reg);
|
||||||
|
quantum_toffoli(control, 2*width+i+2, width+i, reg);
|
||||||
|
quantum_toffoli(control, width+i, 2*width+i+2, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply the 2x2 matrix M to the target bit. M should be unitary and
|
||||||
|
having a determinant of 1. */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_gate1(int target, quantum_matrix m, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i, j, k;
|
||||||
|
int addsize=0, decsize=0;
|
||||||
|
COMPLEX_FLOAT t, tnot=0;
|
||||||
|
char *done;
|
||||||
|
quantum_reg out;
|
||||||
|
quantum_reg_hash *p;
|
||||||
|
|
||||||
|
if((m.cols != 2) || (m.rows != 2))
|
||||||
|
{
|
||||||
|
printf("Matrix is not a 2x2 matrix!\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Build hash table */
|
||||||
|
|
||||||
|
for(i=0; i<(1 << reg->hashw); i++)
|
||||||
|
{
|
||||||
|
while(reg->hash[i])
|
||||||
|
{
|
||||||
|
p = reg->hash[i]->next;
|
||||||
|
free(reg->hash[i]);
|
||||||
|
quantum_memman(-sizeof(quantum_reg_hash));
|
||||||
|
reg->hash[i] = p;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
quantum_add_hash(reg->node[i].state, i, reg);
|
||||||
|
|
||||||
|
/* calculate the number of base states to be added */
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
j = quantum_get_state(reg->node[i].state ^ ((MAX_UNSIGNED) 1 << target),
|
||||||
|
*reg);
|
||||||
|
if(j == -1)
|
||||||
|
{
|
||||||
|
if((m.t[1] != 0) && (reg->node[i].state
|
||||||
|
& ((MAX_UNSIGNED) 1 << target)))
|
||||||
|
addsize++;
|
||||||
|
if((m.t[2] != 0) && !(reg->node[i].state
|
||||||
|
& ((MAX_UNSIGNED) 1 << target)))
|
||||||
|
addsize++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* allocate memory for the new base states */
|
||||||
|
|
||||||
|
reg->node = realloc(reg->node,
|
||||||
|
(reg->size + addsize) * sizeof(quantum_reg_node));
|
||||||
|
if(!reg->node)
|
||||||
|
{
|
||||||
|
printf("Not enough memory for %i-sized qubit!\n", reg->size + addsize);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
quantum_memman(addsize*sizeof(quantum_reg_node));
|
||||||
|
|
||||||
|
for(i=0; i<addsize; i++)
|
||||||
|
{
|
||||||
|
reg->node[i+reg->size].state = 0;
|
||||||
|
reg->node[i+reg->size].amplitude = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
done = calloc(reg->size + addsize, sizeof(char));
|
||||||
|
if(!done)
|
||||||
|
{
|
||||||
|
printf("Not enough memory for %i bytes array!\n",
|
||||||
|
(reg->size + addsize) * sizeof(char));
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
quantum_memman(reg->size + addsize * sizeof(char));
|
||||||
|
|
||||||
|
k = reg->size;
|
||||||
|
|
||||||
|
/* perform the actual matrix multiplication */
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
if(!done[i])
|
||||||
|
{
|
||||||
|
tnot = 0;
|
||||||
|
j = quantum_get_state(reg->node[i].state
|
||||||
|
^ ((MAX_UNSIGNED) 1<<target), *reg);
|
||||||
|
t = reg->node[i].amplitude;
|
||||||
|
|
||||||
|
if(j >= 0)
|
||||||
|
tnot = reg->node[j].amplitude;
|
||||||
|
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << target))
|
||||||
|
reg->node[i].amplitude = m.t[2] * tnot + m.t[3] * t;
|
||||||
|
|
||||||
|
else
|
||||||
|
reg->node[i].amplitude = m.t[0] * t + m.t[1] * tnot;
|
||||||
|
|
||||||
|
if(j >= 0)
|
||||||
|
{
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << target))
|
||||||
|
reg->node[j].amplitude = m.t[0] * tnot + m.t[1] * t;
|
||||||
|
|
||||||
|
else
|
||||||
|
reg->node[j].amplitude = m.t[2] * t + m.t[3] * tnot;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
else /* new base state will be created */
|
||||||
|
{
|
||||||
|
|
||||||
|
if((m.t[1] == 0)
|
||||||
|
&& (reg->node[i].state & ((MAX_UNSIGNED) 1 << target)))
|
||||||
|
break;
|
||||||
|
if((m.t[2] == 0)
|
||||||
|
&& !(reg->node[i].state & ((MAX_UNSIGNED) 1 << target)))
|
||||||
|
break;
|
||||||
|
|
||||||
|
reg->node[k].state = reg->node[i].state
|
||||||
|
^ ((MAX_UNSIGNED) 1 << target);
|
||||||
|
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << target))
|
||||||
|
reg->node[k].amplitude = m.t[1] * t;
|
||||||
|
|
||||||
|
else
|
||||||
|
reg->node[k].amplitude = m.t[2] * t;
|
||||||
|
|
||||||
|
k++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(j >= 0)
|
||||||
|
done[j] = 1;
|
||||||
|
|
||||||
|
if(!reg->node[i].amplitude)
|
||||||
|
decsize++;
|
||||||
|
|
||||||
|
if(j >= 0)
|
||||||
|
{
|
||||||
|
if(!reg->node[j].amplitude)
|
||||||
|
decsize++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
reg->size += addsize;
|
||||||
|
|
||||||
|
free(done);
|
||||||
|
quantum_memman(-reg->size * sizeof(char));
|
||||||
|
|
||||||
|
/* remove base states with zero amplitude */
|
||||||
|
|
||||||
|
if(decsize)
|
||||||
|
{
|
||||||
|
out.width = reg->width;
|
||||||
|
out.size = reg->size - decsize;
|
||||||
|
out.node = calloc(out.size, sizeof(quantum_reg_node));
|
||||||
|
if(!out.node)
|
||||||
|
{
|
||||||
|
printf("Not enough memory for %i-sized qubit!\n", out.size);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
quantum_memman(out.size * sizeof(quantum_reg_node));
|
||||||
|
out.hashw = reg->hashw;
|
||||||
|
out.hash = reg->hash;
|
||||||
|
|
||||||
|
for(i=0, j=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
if(reg->node[i].amplitude)
|
||||||
|
{
|
||||||
|
out.node[j].state = reg->node[i].state;
|
||||||
|
out.node[j].amplitude = reg->node[i].amplitude;
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
quantum_delete_qureg(reg);
|
||||||
|
*reg = out;
|
||||||
|
}
|
||||||
|
|
||||||
|
quantum_decohere(reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply a hadamard gate */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_hadamard(int target, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
quantum_matrix m;
|
||||||
|
|
||||||
|
m = quantum_new_matrix(2, 2);
|
||||||
|
|
||||||
|
m.t[0] = sqrt(1.0/2); m.t[1] = sqrt(1.0/2);
|
||||||
|
m.t[2] = sqrt(1.0/2); m.t[3] = -sqrt(1.0/2);
|
||||||
|
|
||||||
|
quantum_gate1(target, m, reg);
|
||||||
|
|
||||||
|
quantum_delete_matrix(&m);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply a walsh-hadamard gate */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_walsh(int target, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
quantum_matrix m;
|
||||||
|
|
||||||
|
m = quantum_new_matrix(2, 2);
|
||||||
|
|
||||||
|
m.t[0] = IMAGINARY*sqrt(1.0/2); m.t[1] = IMAGINARY*sqrt(1.0/2);
|
||||||
|
m.t[2] = IMAGINARY*sqrt(1.0/2); m.t[3] = -IMAGINARY*sqrt(1.0/2);
|
||||||
|
|
||||||
|
quantum_gate1(target, m, reg);
|
||||||
|
|
||||||
|
quantum_delete_matrix(&m);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply a rotation about the x-axis by the angle GAMMA */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_r_x(int target, float gamma, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
quantum_matrix m;
|
||||||
|
|
||||||
|
m = quantum_new_matrix(2, 2);
|
||||||
|
|
||||||
|
m.t[0] = cos(gamma / 2); m.t[1] = IMAGINARY * sin(gamma / 2);
|
||||||
|
m.t[2] = IMAGINARY * sin(gamma / 2); m.t[3] = cos(gamma / 2);
|
||||||
|
|
||||||
|
quantum_gate1(target, m, reg);
|
||||||
|
|
||||||
|
quantum_delete_matrix(&m);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply a rotation about the y-axis by the angle GAMMA */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_r_y(int target, float gamma, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
quantum_matrix m;
|
||||||
|
|
||||||
|
m = quantum_new_matrix(2, 2);
|
||||||
|
|
||||||
|
m.t[0] = cos(gamma / 2); m.t[1] = -sin(gamma / 2);
|
||||||
|
m.t[2] = sin(gamma / 2); m.t[3] = cos(gamma / 2);
|
||||||
|
|
||||||
|
quantum_gate1(target, m, reg);
|
||||||
|
|
||||||
|
quantum_delete_matrix(&m);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply a phase kick by the angle GAMMA */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_phase_kick(int target, float gamma, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << target))
|
||||||
|
reg->node[i].amplitude *= quantum_cexp(gamma);
|
||||||
|
}
|
||||||
|
|
||||||
|
quantum_decohere(reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Apply a conditional phase shift by PI / 2^(CONTROL - TARGET) */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_cond_phase(int control, int target, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << control))
|
||||||
|
{
|
||||||
|
if(reg->node[i].state & ((MAX_UNSIGNED) 1 << target))
|
||||||
|
reg->node[i].amplitude
|
||||||
|
*= quantum_cexp(pi / ((MAX_UNSIGNED) 1 << (control - target)));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
quantum_decohere(reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Increase the gate counter by INC steps or reset it if INC < 0. The
|
||||||
|
current value of the counter is returned. */
|
||||||
|
|
||||||
|
int
|
||||||
|
quantum_gate_counter(int inc)
|
||||||
|
{
|
||||||
|
static int counter = 0;
|
||||||
|
|
||||||
|
if(inc > 0)
|
||||||
|
counter += inc;
|
||||||
|
else if(inc < 0)
|
||||||
|
counter = 0;
|
||||||
|
|
||||||
|
return counter;
|
||||||
|
}
|
||||||
55
gates.h
Normal file
55
gates.h
Normal file
@@ -0,0 +1,55 @@
|
|||||||
|
/* gates.h: Declarations for gates.c
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __GATES_H
|
||||||
|
|
||||||
|
#define __GATES_H
|
||||||
|
|
||||||
|
#include "matrix.h"
|
||||||
|
#include "qureg.h"
|
||||||
|
|
||||||
|
extern void quantum_cnot(int control, int target, quantum_reg *reg);
|
||||||
|
extern void quantum_toffoli(int control1, int control2, int target,
|
||||||
|
quantum_reg *reg);
|
||||||
|
extern void quantum_sigma_x(int target, quantum_reg *reg);
|
||||||
|
extern void quantum_sigma_y(int target, quantum_reg *reg);
|
||||||
|
extern void quantum_sigma_z(int target, quantum_reg *reg);
|
||||||
|
|
||||||
|
extern void quantum_swaptheleads(int width, quantum_reg *reg);
|
||||||
|
extern void quantum_swaptheleads_omuln_controlled(int control, int width,
|
||||||
|
quantum_reg *);
|
||||||
|
|
||||||
|
extern void quantum_gate1(int target, quantum_matrix m, quantum_reg *reg);
|
||||||
|
|
||||||
|
extern void quantum_r_x(int a, float gamma, quantum_reg *reg);
|
||||||
|
extern void quantum_r_y(int a, float gamma, quantum_reg *reg);
|
||||||
|
|
||||||
|
extern void quantum_hadamard(int a, quantum_reg *reg);
|
||||||
|
extern void quantum_walsh(int a, quantum_reg *reg);
|
||||||
|
|
||||||
|
extern void quantum_phase_kick(int a, float gamma, quantum_reg *reg);
|
||||||
|
extern void quantum_cond_phase(int a, int b, quantum_reg *reg);
|
||||||
|
|
||||||
|
extern int quantum_gate_counter(int inc);
|
||||||
|
|
||||||
|
#endif
|
||||||
251
install-sh
Executable file
251
install-sh
Executable file
@@ -0,0 +1,251 @@
|
|||||||
|
#!/bin/sh
|
||||||
|
#
|
||||||
|
# install - install a program, script, or datafile
|
||||||
|
# This comes from X11R5 (mit/util/scripts/install.sh).
|
||||||
|
#
|
||||||
|
# Copyright 1991 by the Massachusetts Institute of Technology
|
||||||
|
#
|
||||||
|
# Permission to use, copy, modify, distribute, and sell this software and its
|
||||||
|
# documentation for any purpose is hereby granted without fee, provided that
|
||||||
|
# the above copyright notice appear in all copies and that both that
|
||||||
|
# copyright notice and this permission notice appear in supporting
|
||||||
|
# documentation, and that the name of M.I.T. not be used in advertising or
|
||||||
|
# publicity pertaining to distribution of the software without specific,
|
||||||
|
# written prior permission. M.I.T. makes no representations about the
|
||||||
|
# suitability of this software for any purpose. It is provided "as is"
|
||||||
|
# without express or implied warranty.
|
||||||
|
#
|
||||||
|
# Calling this script install-sh is preferred over install.sh, to prevent
|
||||||
|
# `make' implicit rules from creating a file called install from it
|
||||||
|
# when there is no Makefile.
|
||||||
|
#
|
||||||
|
# This script is compatible with the BSD install script, but was written
|
||||||
|
# from scratch. It can only install one file at a time, a restriction
|
||||||
|
# shared with many OS's install programs.
|
||||||
|
|
||||||
|
|
||||||
|
# set DOITPROG to echo to test this script
|
||||||
|
|
||||||
|
# Don't use :- since 4.3BSD and earlier shells don't like it.
|
||||||
|
doit="${DOITPROG-}"
|
||||||
|
|
||||||
|
|
||||||
|
# put in absolute paths if you don't have them in your path; or use env. vars.
|
||||||
|
|
||||||
|
mvprog="${MVPROG-mv}"
|
||||||
|
cpprog="${CPPROG-cp}"
|
||||||
|
chmodprog="${CHMODPROG-chmod}"
|
||||||
|
chownprog="${CHOWNPROG-chown}"
|
||||||
|
chgrpprog="${CHGRPPROG-chgrp}"
|
||||||
|
stripprog="${STRIPPROG-strip}"
|
||||||
|
rmprog="${RMPROG-rm}"
|
||||||
|
mkdirprog="${MKDIRPROG-mkdir}"
|
||||||
|
|
||||||
|
transformbasename=""
|
||||||
|
transform_arg=""
|
||||||
|
instcmd="$mvprog"
|
||||||
|
chmodcmd="$chmodprog 0755"
|
||||||
|
chowncmd=""
|
||||||
|
chgrpcmd=""
|
||||||
|
stripcmd=""
|
||||||
|
rmcmd="$rmprog -f"
|
||||||
|
mvcmd="$mvprog"
|
||||||
|
src=""
|
||||||
|
dst=""
|
||||||
|
dir_arg=""
|
||||||
|
|
||||||
|
while [ x"$1" != x ]; do
|
||||||
|
case $1 in
|
||||||
|
-c) instcmd="$cpprog"
|
||||||
|
shift
|
||||||
|
continue;;
|
||||||
|
|
||||||
|
-d) dir_arg=true
|
||||||
|
shift
|
||||||
|
continue;;
|
||||||
|
|
||||||
|
-m) chmodcmd="$chmodprog $2"
|
||||||
|
shift
|
||||||
|
shift
|
||||||
|
continue;;
|
||||||
|
|
||||||
|
-o) chowncmd="$chownprog $2"
|
||||||
|
shift
|
||||||
|
shift
|
||||||
|
continue;;
|
||||||
|
|
||||||
|
-g) chgrpcmd="$chgrpprog $2"
|
||||||
|
shift
|
||||||
|
shift
|
||||||
|
continue;;
|
||||||
|
|
||||||
|
-s) stripcmd="$stripprog"
|
||||||
|
shift
|
||||||
|
continue;;
|
||||||
|
|
||||||
|
-t=*) transformarg=`echo $1 | sed 's/-t=//'`
|
||||||
|
shift
|
||||||
|
continue;;
|
||||||
|
|
||||||
|
-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
|
||||||
|
shift
|
||||||
|
continue;;
|
||||||
|
|
||||||
|
*) if [ x"$src" = x ]
|
||||||
|
then
|
||||||
|
src=$1
|
||||||
|
else
|
||||||
|
# this colon is to work around a 386BSD /bin/sh bug
|
||||||
|
:
|
||||||
|
dst=$1
|
||||||
|
fi
|
||||||
|
shift
|
||||||
|
continue;;
|
||||||
|
esac
|
||||||
|
done
|
||||||
|
|
||||||
|
if [ x"$src" = x ]
|
||||||
|
then
|
||||||
|
echo "install: no input file specified"
|
||||||
|
exit 1
|
||||||
|
else
|
||||||
|
true
|
||||||
|
fi
|
||||||
|
|
||||||
|
if [ x"$dir_arg" != x ]; then
|
||||||
|
dst=$src
|
||||||
|
src=""
|
||||||
|
|
||||||
|
if [ -d $dst ]; then
|
||||||
|
instcmd=:
|
||||||
|
chmodcmd=""
|
||||||
|
else
|
||||||
|
instcmd=mkdir
|
||||||
|
fi
|
||||||
|
else
|
||||||
|
|
||||||
|
# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
|
||||||
|
# might cause directories to be created, which would be especially bad
|
||||||
|
# if $src (and thus $dsttmp) contains '*'.
|
||||||
|
|
||||||
|
if [ -f $src -o -d $src ]
|
||||||
|
then
|
||||||
|
true
|
||||||
|
else
|
||||||
|
echo "install: $src does not exist"
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
|
||||||
|
if [ x"$dst" = x ]
|
||||||
|
then
|
||||||
|
echo "install: no destination specified"
|
||||||
|
exit 1
|
||||||
|
else
|
||||||
|
true
|
||||||
|
fi
|
||||||
|
|
||||||
|
# If destination is a directory, append the input filename; if your system
|
||||||
|
# does not like double slashes in filenames, you may need to add some logic
|
||||||
|
|
||||||
|
if [ -d $dst ]
|
||||||
|
then
|
||||||
|
dst="$dst"/`basename $src`
|
||||||
|
else
|
||||||
|
true
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
## this sed command emulates the dirname command
|
||||||
|
dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
|
||||||
|
|
||||||
|
# Make sure that the destination directory exists.
|
||||||
|
# this part is taken from Noah Friedman's mkinstalldirs script
|
||||||
|
|
||||||
|
# Skip lots of stat calls in the usual case.
|
||||||
|
if [ ! -d "$dstdir" ]; then
|
||||||
|
defaultIFS='
|
||||||
|
'
|
||||||
|
IFS="${IFS-${defaultIFS}}"
|
||||||
|
|
||||||
|
oIFS="${IFS}"
|
||||||
|
# Some sh's can't handle IFS=/ for some reason.
|
||||||
|
IFS='%'
|
||||||
|
set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
|
||||||
|
IFS="${oIFS}"
|
||||||
|
|
||||||
|
pathcomp=''
|
||||||
|
|
||||||
|
while [ $# -ne 0 ] ; do
|
||||||
|
pathcomp="${pathcomp}${1}"
|
||||||
|
shift
|
||||||
|
|
||||||
|
if [ ! -d "${pathcomp}" ] ;
|
||||||
|
then
|
||||||
|
$mkdirprog "${pathcomp}"
|
||||||
|
else
|
||||||
|
true
|
||||||
|
fi
|
||||||
|
|
||||||
|
pathcomp="${pathcomp}/"
|
||||||
|
done
|
||||||
|
fi
|
||||||
|
|
||||||
|
if [ x"$dir_arg" != x ]
|
||||||
|
then
|
||||||
|
$doit $instcmd $dst &&
|
||||||
|
|
||||||
|
if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
|
||||||
|
if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
|
||||||
|
if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
|
||||||
|
if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
|
||||||
|
else
|
||||||
|
|
||||||
|
# If we're going to rename the final executable, determine the name now.
|
||||||
|
|
||||||
|
if [ x"$transformarg" = x ]
|
||||||
|
then
|
||||||
|
dstfile=`basename $dst`
|
||||||
|
else
|
||||||
|
dstfile=`basename $dst $transformbasename |
|
||||||
|
sed $transformarg`$transformbasename
|
||||||
|
fi
|
||||||
|
|
||||||
|
# don't allow the sed command to completely eliminate the filename
|
||||||
|
|
||||||
|
if [ x"$dstfile" = x ]
|
||||||
|
then
|
||||||
|
dstfile=`basename $dst`
|
||||||
|
else
|
||||||
|
true
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Make a temp file name in the proper directory.
|
||||||
|
|
||||||
|
dsttmp=$dstdir/#inst.$$#
|
||||||
|
|
||||||
|
# Move or copy the file name to the temp name
|
||||||
|
|
||||||
|
$doit $instcmd $src $dsttmp &&
|
||||||
|
|
||||||
|
trap "rm -f ${dsttmp}" 0 &&
|
||||||
|
|
||||||
|
# and set any options; do chmod last to preserve setuid bits
|
||||||
|
|
||||||
|
# If any of these fail, we abort the whole thing. If we want to
|
||||||
|
# ignore errors from any of these, just make sure not to ignore
|
||||||
|
# errors from the above "$doit $instcmd $src $dsttmp" command.
|
||||||
|
|
||||||
|
if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
|
||||||
|
if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
|
||||||
|
if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
|
||||||
|
if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
|
||||||
|
|
||||||
|
# Now rename the file to the real destination.
|
||||||
|
|
||||||
|
$doit $rmcmd -f $dstdir/$dstfile &&
|
||||||
|
$doit $mvcmd $dsttmp $dstdir/$dstfile
|
||||||
|
|
||||||
|
fi &&
|
||||||
|
|
||||||
|
|
||||||
|
exit 0
|
||||||
113
matrix.c
Normal file
113
matrix.c
Normal file
@@ -0,0 +1,113 @@
|
|||||||
|
/* matrix.c: Matrix operations
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
#include "matrix.h"
|
||||||
|
#include "config.h"
|
||||||
|
#include "complex.h"
|
||||||
|
|
||||||
|
/* Statistics of the memory consumption */
|
||||||
|
|
||||||
|
unsigned long quantum_memman(long change)
|
||||||
|
{
|
||||||
|
static long mem = 0, max = 0;
|
||||||
|
|
||||||
|
mem += change;
|
||||||
|
|
||||||
|
if(mem > max)
|
||||||
|
max = mem;
|
||||||
|
|
||||||
|
return max;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Create a new COLS x ROWS matrix */
|
||||||
|
|
||||||
|
quantum_matrix
|
||||||
|
quantum_new_matrix(int cols, int rows)
|
||||||
|
{
|
||||||
|
quantum_matrix m;
|
||||||
|
|
||||||
|
m.rows = rows;
|
||||||
|
m.cols = cols;
|
||||||
|
m.t = calloc(cols * rows, sizeof(COMPLEX_FLOAT));
|
||||||
|
|
||||||
|
#if (DEBUG_MEM)
|
||||||
|
printf("allocating %i bytes of memory for %ix%i matrix at 0x%X\n",
|
||||||
|
sizeof(COMPLEX_FLOAT) * cols * rows, cols, rows, (int) m.t);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if(!m.t)
|
||||||
|
{
|
||||||
|
printf("Not enogh memory for %ix%i-Matrix!",rows,cols);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
quantum_memman(sizeof(COMPLEX_FLOAT) * cols * rows);
|
||||||
|
|
||||||
|
return m;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Delete a matrix */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_delete_matrix(quantum_matrix *m)
|
||||||
|
{
|
||||||
|
#if (DEBUG_MEM)
|
||||||
|
printf("freeing %i bytes of memory for %ix%i matrix at 0x%X\n",
|
||||||
|
sizeof(COMPLEX_FLOAT) * m->cols * m->rows, m->cols, m->rows,
|
||||||
|
(int) m->t);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
free(m->t);
|
||||||
|
quantum_memman(-sizeof(COMPLEX_FLOAT) * m->cols * m->rows);
|
||||||
|
m->t=0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Print the contents of a matrix to stdout */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_print_matrix(quantum_matrix m)
|
||||||
|
{
|
||||||
|
int i, j, l, z=0;
|
||||||
|
|
||||||
|
while ((1 << z++) < m.rows);
|
||||||
|
z--;
|
||||||
|
|
||||||
|
for(i=0; i<m.rows; i++)
|
||||||
|
{
|
||||||
|
for (l=z-1; l>=0; l--)
|
||||||
|
{
|
||||||
|
if ((l % 4 == 3))
|
||||||
|
printf(" ");
|
||||||
|
printf("%i", (i >> l) & 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
printf(" | ");
|
||||||
|
|
||||||
|
for(j=0; j<m.cols; j++)
|
||||||
|
printf("%f %fi ", quantum_real(M(m, j, i)), quantum_imag(M(m, j, i)));
|
||||||
|
printf("|\n");
|
||||||
|
}
|
||||||
|
printf("\n");
|
||||||
|
}
|
||||||
48
matrix.h
Normal file
48
matrix.h
Normal file
@@ -0,0 +1,48 @@
|
|||||||
|
/* matrix.h: Declarations for matrix.c
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __MATRIX_H
|
||||||
|
|
||||||
|
#define __MATRIX_H
|
||||||
|
|
||||||
|
#include "config.h"
|
||||||
|
|
||||||
|
/* A ROWS x COLS matrix with complex elements */
|
||||||
|
|
||||||
|
struct quantum_matrix_struct {
|
||||||
|
int rows;
|
||||||
|
int cols;
|
||||||
|
COMPLEX_FLOAT *t;
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct quantum_matrix_struct quantum_matrix;
|
||||||
|
|
||||||
|
#define M(m,x,y) m.t[x+y*m.cols]
|
||||||
|
|
||||||
|
extern unsigned long quantum_memman(long change);
|
||||||
|
|
||||||
|
extern quantum_matrix quantum_new_matrix(int cols, int rows);
|
||||||
|
extern void quantum_delete_matrix(quantum_matrix *m);
|
||||||
|
extern void quantum_print_matrix(quantum_matrix m);
|
||||||
|
|
||||||
|
#endif
|
||||||
175
measure.c
Normal file
175
measure.c
Normal file
@@ -0,0 +1,175 @@
|
|||||||
|
/* measure.c: Quantum register measurement
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
#include <sys/stat.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <math.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
#include "qureg.h"
|
||||||
|
#include "complex.h"
|
||||||
|
#include "config.h"
|
||||||
|
|
||||||
|
/* Generate a uniformly distributed random number between 0 and 1 */
|
||||||
|
|
||||||
|
double
|
||||||
|
quantum_frand()
|
||||||
|
{
|
||||||
|
return (double) rand() / RAND_MAX;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Measure the contents of a quantum register */
|
||||||
|
|
||||||
|
MAX_UNSIGNED
|
||||||
|
quantum_measure(quantum_reg reg)
|
||||||
|
{
|
||||||
|
double r;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
/* Get a random number between 0 and 1 */
|
||||||
|
|
||||||
|
r = quantum_frand();
|
||||||
|
|
||||||
|
for (i=0; i<reg.size; i++)
|
||||||
|
{
|
||||||
|
/* If the random number is less than the probability of the
|
||||||
|
given base state - r, return the base state as the
|
||||||
|
result. Otherwise, continue with the next base state. */
|
||||||
|
|
||||||
|
r -= quantum_prob(reg.node[i].amplitude);
|
||||||
|
if(quantum_prob(reg.node[i].amplitude) >= r)
|
||||||
|
return reg.node[i].state;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* The sum of all probabilities is less than 1. Usually, the cause
|
||||||
|
for this is the application of a non-normalized matrix, but there
|
||||||
|
is a slim chance that rounding errors may lead to this as
|
||||||
|
well. */
|
||||||
|
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Measure a single bit of a quantum register. The bit measured is
|
||||||
|
indicated by its position POS, starting with 0 as the least
|
||||||
|
significant bit. The new state of the quantum register depends on
|
||||||
|
the result of the measurement. */
|
||||||
|
|
||||||
|
int
|
||||||
|
quantum_bmeasure(int pos, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i, j, k;
|
||||||
|
int size=0, result=0;
|
||||||
|
double d=0, pa=0, r;
|
||||||
|
MAX_UNSIGNED lpat=0, rpat=0, pos2;
|
||||||
|
quantum_reg out;
|
||||||
|
|
||||||
|
pos2 = 1 << pos;
|
||||||
|
|
||||||
|
/* Sum up the probability for 0 being the result */
|
||||||
|
|
||||||
|
for(i=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
if(!(reg->node[i].state & pos2))
|
||||||
|
pa += quantum_prob(reg->node[i].amplitude);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Compare the probability for 0 with a random number and determine
|
||||||
|
the result of the measurement */
|
||||||
|
|
||||||
|
r = quantum_frand();
|
||||||
|
|
||||||
|
if (r > pa)
|
||||||
|
result = 1;
|
||||||
|
|
||||||
|
/* Eradicate all amplitudes of base states which have been ruled out
|
||||||
|
by the measurement and get the absolute of the new register */
|
||||||
|
|
||||||
|
for(i=0;i<reg->size;i++)
|
||||||
|
{
|
||||||
|
if(reg->node[i].state & pos2)
|
||||||
|
{
|
||||||
|
if(!result)
|
||||||
|
reg->node[i].amplitude = 0;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
d += quantum_prob(reg->node[i].amplitude);
|
||||||
|
size++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if(result)
|
||||||
|
reg->node[i].amplitude = 0;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
d += quantum_prob(reg->node[i].amplitude);
|
||||||
|
size++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Build the new quantum register */
|
||||||
|
|
||||||
|
out.width = reg->width-1;
|
||||||
|
out.size = size;
|
||||||
|
out.node = calloc(size, sizeof(quantum_reg_node));
|
||||||
|
if(!out.node)
|
||||||
|
{
|
||||||
|
printf("Not enough memory for %i-sized qubit!\n", size);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
quantum_memman(size * sizeof(quantum_reg_node));
|
||||||
|
out.hashw = reg->hashw;
|
||||||
|
out.hash = reg->hash;
|
||||||
|
|
||||||
|
/* Determine the numbers of the new base states and norm the quantum
|
||||||
|
register */
|
||||||
|
|
||||||
|
for(i=0, j=0; i<reg->size; i++)
|
||||||
|
{
|
||||||
|
if(reg->node[i].amplitude)
|
||||||
|
{
|
||||||
|
for(k=0, rpat=0; k<pos; k++)
|
||||||
|
rpat += (MAX_UNSIGNED) 1 << k;
|
||||||
|
|
||||||
|
rpat &= reg->node[i].state;
|
||||||
|
|
||||||
|
for(k=sizeof(MAX_UNSIGNED)*8-1, lpat=0; k>pos; k--)
|
||||||
|
lpat += (MAX_UNSIGNED) 1 << k;
|
||||||
|
|
||||||
|
lpat &= reg->node[i].state;
|
||||||
|
|
||||||
|
out.node[j].state = (lpat >> 1) | rpat;
|
||||||
|
out.node[j].amplitude = reg->node[i].amplitude * 1 / (float) sqrt(d);
|
||||||
|
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
quantum_delete_qureg(reg);
|
||||||
|
*reg = out;
|
||||||
|
return result;
|
||||||
|
}
|
||||||
37
measure.h
Normal file
37
measure.h
Normal file
@@ -0,0 +1,37 @@
|
|||||||
|
/* measure.h: Declarations for measure.c
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __MEASURE_H
|
||||||
|
|
||||||
|
#define __MEASURE_H
|
||||||
|
|
||||||
|
#include "matrix.h"
|
||||||
|
#include "qureg.h"
|
||||||
|
#include "config.h"
|
||||||
|
|
||||||
|
extern double quantum_frand();
|
||||||
|
|
||||||
|
extern MAX_UNSIGNED quantum_measure(quantum_reg reg);
|
||||||
|
extern int quantum_bmeasure(int pos, quantum_reg *reg);
|
||||||
|
|
||||||
|
#endif
|
||||||
312
oaddn.c
Normal file
312
oaddn.c
Normal file
@@ -0,0 +1,312 @@
|
|||||||
|
/* oaddn.c: Addition modulo an integer N
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <math.h>
|
||||||
|
|
||||||
|
#include "matrix.h"
|
||||||
|
#include "measure.h"
|
||||||
|
#include "defs.h"
|
||||||
|
#include "gates.h"
|
||||||
|
#include "qureg.h"
|
||||||
|
#include "config.h"
|
||||||
|
|
||||||
|
|
||||||
|
/* if bit "compare" - the global enable bit - is set, test_sums
|
||||||
|
checks, if the sum of the c-number and the q-number in register
|
||||||
|
add_sum is greater than n and sets the next lower bit to "compare" */
|
||||||
|
|
||||||
|
void
|
||||||
|
test_sum(int compare, int width, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
if (compare & ((MAX_UNSIGNED) 1 << (width - 1)))
|
||||||
|
{
|
||||||
|
quantum_cnot(2*width-1, width-1, reg);
|
||||||
|
quantum_sigma_x(2*width-1, reg);
|
||||||
|
quantum_cnot(2*width-1, 0, reg);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
quantum_sigma_x(2*width-1, reg);
|
||||||
|
quantum_cnot(2*width-1,width-1, reg);
|
||||||
|
}
|
||||||
|
for (i = (width-2);i>0;i--)
|
||||||
|
{
|
||||||
|
if (compare & (1<<i))
|
||||||
|
{//is bit i set in compare?
|
||||||
|
quantum_toffoli(i+1,width+i,i, reg);
|
||||||
|
quantum_sigma_x(width+i, reg);
|
||||||
|
quantum_toffoli(i+1,width+i,0, reg);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
quantum_sigma_x(width+i, reg);
|
||||||
|
quantum_toffoli(i+1,width+i,i, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (compare & 1)
|
||||||
|
{
|
||||||
|
quantum_sigma_x(width, reg);
|
||||||
|
quantum_toffoli(width,1,0, reg);
|
||||||
|
}
|
||||||
|
quantum_toffoli(2*width+1,0,2*width, reg);//set output to 1 if enabled and b < compare
|
||||||
|
|
||||||
|
if (compare & 1)
|
||||||
|
{
|
||||||
|
quantum_toffoli(width,1,0, reg);
|
||||||
|
quantum_sigma_x(width, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 1;i<=(width-2);i++)
|
||||||
|
{
|
||||||
|
if (compare & (1<<i))
|
||||||
|
{//is bit i set in compare?
|
||||||
|
quantum_toffoli(i+1,width+i,0, reg);
|
||||||
|
quantum_sigma_x(width+i, reg);
|
||||||
|
quantum_toffoli(i+1,width+i,i, reg);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
quantum_toffoli(i+1,width+i,i, reg);
|
||||||
|
quantum_sigma_x(width+i, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (compare & (1<<(width-1)))
|
||||||
|
{
|
||||||
|
quantum_cnot(2*width-1,0, reg);
|
||||||
|
quantum_sigma_x(2*width-1, reg);
|
||||||
|
quantum_cnot(2*width-1,width-1, reg);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
quantum_cnot(2*width-1,width-1, reg);
|
||||||
|
quantum_sigma_x(2*width-1, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//This is a semi-quantum fulladder. It adds to b_in
|
||||||
|
//a c-number. Carry-in bit is c_in and carry_out is
|
||||||
|
//c_out. xlt-l and L are enablebits. See documentation
|
||||||
|
//for further information
|
||||||
|
|
||||||
|
void muxfa(int a, int b_in, int c_in, int c_out, int xlt_l,int L, int total,quantum_reg *reg){//a,
|
||||||
|
|
||||||
|
if(a==0){//00
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
if(a==3){//11
|
||||||
|
quantum_toffoli(L,c_in,c_out, reg);
|
||||||
|
quantum_cnot(L,c_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
if(a==1){//01
|
||||||
|
quantum_toffoli(L,xlt_l,b_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,b_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,c_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
if(a==2){//10
|
||||||
|
quantum_sigma_x(xlt_l, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,b_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,b_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,c_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
quantum_sigma_x(xlt_l, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//This is just the inverse operation of the semi-quantum fulladder
|
||||||
|
|
||||||
|
void muxfa_inv(int a,int b_in,int c_in,int c_out, int xlt_l,int L,int total,quantum_reg *reg){//a,
|
||||||
|
|
||||||
|
if(a==0){//00
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
if(a==3){//11
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_cnot(L,c_in, reg);
|
||||||
|
quantum_toffoli(L,c_in,c_out, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
if(a==1){//01
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,c_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,b_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,b_in, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
if(a==2){//10
|
||||||
|
quantum_sigma_x(xlt_l, reg);
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,c_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,b_in, reg);
|
||||||
|
quantum_toffoli(b_in,c_in,c_out, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,b_in, reg);
|
||||||
|
quantum_sigma_x(xlt_l, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//This is a semi-quantum halfadder. It adds to b_in
|
||||||
|
//a c-number. Carry-in bit is c_in and carry_out is
|
||||||
|
//not necessary. xlt-l and L are enablebits. See
|
||||||
|
//documentation for further information
|
||||||
|
|
||||||
|
void muxha(int a,int b_in,int c_in, int xlt_l, int L,int total,quantum_reg *reg){//a,
|
||||||
|
|
||||||
|
if(a==0){//00
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
if(a==3){//11
|
||||||
|
quantum_cnot(L,c_in, reg);
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
if(a==1){//01
|
||||||
|
quantum_toffoli(L,xlt_l,c_in, reg);
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
if(a==2){//10
|
||||||
|
quantum_sigma_x(xlt_l, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,c_in, reg);
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
quantum_sigma_x(xlt_l, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//just the inverse of the semi quantum-halfadder
|
||||||
|
|
||||||
|
void muxha_inv(int a,int b_in,int c_in, int xlt_l, int L, int total,quantum_reg *reg){//a,
|
||||||
|
|
||||||
|
if(a==0){//00
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
if(a==3){//11
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
quantum_cnot(L,c_in, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
if(a==1){//01
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,c_in, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
if(a==2){//10
|
||||||
|
quantum_sigma_x(xlt_l, reg);
|
||||||
|
quantum_cnot(b_in,c_in, reg);
|
||||||
|
quantum_toffoli(L,xlt_l,c_in, reg);
|
||||||
|
quantum_sigma_x(xlt_l, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//
|
||||||
|
|
||||||
|
void madd(int a,int a_inv,int width,quantum_reg *reg){
|
||||||
|
int i,j;
|
||||||
|
int total;
|
||||||
|
total = num_regs*width+2;
|
||||||
|
for (i = 0; i< width-1; i++){
|
||||||
|
if((1<<i) & a) j= 1<<1;
|
||||||
|
else j=0;
|
||||||
|
if((1<<i) & a_inv) j+=1;
|
||||||
|
muxfa(j,width+i,i,i+1,2*width,2*width+1, total, reg);
|
||||||
|
}
|
||||||
|
j=0;
|
||||||
|
if((1<<(width-1)) & a) j= 2;
|
||||||
|
if((1<<(width-1)) & a_inv) j+=1;
|
||||||
|
muxha(j,2*width-1,width-1,2*width,2*width+1, total, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
void madd_inv(int a,int a_inv,int width,quantum_reg *reg){
|
||||||
|
int i,j;
|
||||||
|
int total;
|
||||||
|
total = num_regs*width+2;
|
||||||
|
j=0;
|
||||||
|
|
||||||
|
if((1<<(width-1)) & a) j= 2;
|
||||||
|
if((1<<(width-1)) & a_inv) j+=1;
|
||||||
|
muxha_inv(j,width-1,2*width-1,2*width, 2*width+1, total, reg);
|
||||||
|
|
||||||
|
for (i = width-2; i>=0; i--){
|
||||||
|
if((1<<i) & a) j= 1<<1;
|
||||||
|
else j=0;
|
||||||
|
if((1<<i) & a_inv) j+=1;
|
||||||
|
muxfa_inv(j,i,width+i,width+1+i,2*width, 2*width+1, total, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void addn(int N,int a,int width, quantum_reg *reg){//add a to register reg (mod N)
|
||||||
|
|
||||||
|
test_sum(N-a,width,reg); //xlt N-a
|
||||||
|
madd((1<<(width))+a-N,a,width,reg);//madd 2^K+a-N
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
void addn_inv(int N,int a,int width, quantum_reg *reg){//inverse of add a to register reg (mod N)
|
||||||
|
|
||||||
|
quantum_cnot(2*width+1,2*width,reg);//Attention! cnot gate instead of not, as in description
|
||||||
|
madd_inv((1<<(width))-a,N-a,width,reg);//madd 2^K+(N-a)-N = 2^K-a
|
||||||
|
|
||||||
|
quantum_swaptheleads(width,reg);
|
||||||
|
|
||||||
|
test_sum(a,width,reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
void add_mod_n(int N,int a,int width, quantum_reg *reg){//add a to register reg (mod N) and clear the scratch bits
|
||||||
|
|
||||||
|
addn(N, a, width, reg);
|
||||||
|
addn_inv(N, a, width, reg);
|
||||||
|
}
|
||||||
|
|
||||||
26
oaddn.h
Normal file
26
oaddn.h
Normal file
@@ -0,0 +1,26 @@
|
|||||||
|
#ifndef __OADDN_H
|
||||||
|
|
||||||
|
#define __OADDN_H
|
||||||
|
|
||||||
|
#include "qureg.h"
|
||||||
|
|
||||||
|
extern void test_sum(int, int, quantum_reg *);
|
||||||
|
|
||||||
|
extern void muxfa(int, int, int, int, int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
extern void muxfa_inv(int, int, int, int, int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
extern void muxha(int, int, int, int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
extern void muxha_inv(int, int, int, int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
extern void madd(int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
extern void madd_inv(int, int, int,quantum_reg *);
|
||||||
|
|
||||||
|
extern void addn(int,int,int, quantum_reg *);
|
||||||
|
|
||||||
|
extern void addn_inv(int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
extern void add_mod_n(int, int, int, quantum_reg *);
|
||||||
|
#endif
|
||||||
60
omuln.c
Normal file
60
omuln.c
Normal file
@@ -0,0 +1,60 @@
|
|||||||
|
#include "defs.h"
|
||||||
|
#include "matrix.h"
|
||||||
|
#include "gates.h"
|
||||||
|
#include "oaddn.h"
|
||||||
|
#include "classic.h"
|
||||||
|
|
||||||
|
void emul(int a, int L, int width, quantum_reg *reg){
|
||||||
|
|
||||||
|
int i;
|
||||||
|
for(i=width-1;i>=0;i--) if ((a>>i) & 1) {
|
||||||
|
quantum_toffoli(2*width+2,L,width+i,reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void muln(int N, int a, int ctl, int width, quantum_reg *reg){//ctl tells, which bit is the external enable bit
|
||||||
|
int i;
|
||||||
|
int L = 2*width+1;
|
||||||
|
|
||||||
|
quantum_toffoli(ctl,2*width+2,L,reg);
|
||||||
|
|
||||||
|
emul(a%N, L, width, reg);
|
||||||
|
|
||||||
|
quantum_toffoli(ctl,2*width+2,L,reg);
|
||||||
|
|
||||||
|
for(i=1;i<width;i++){
|
||||||
|
quantum_toffoli(ctl,2*width+2+i,L,reg);
|
||||||
|
add_mod_n(N,((1<<i)*a)%N,width,reg);
|
||||||
|
quantum_toffoli(ctl,2*width+2+i,L,reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
void muln_inv(int N, int a, int ctl, int width, quantum_reg *reg){//ctl tells, which bit is the external enable bit
|
||||||
|
int i;
|
||||||
|
int L = 2*width+1;
|
||||||
|
|
||||||
|
a=quantum_inverse_mod(N,a);
|
||||||
|
|
||||||
|
for(i=width-1;i>0;i--){
|
||||||
|
quantum_toffoli(ctl,2*width+2+i,L,reg);
|
||||||
|
add_mod_n(N,N-((1<<i)*a)%N,width,reg);
|
||||||
|
quantum_toffoli(ctl,2*width+2+i,L,reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
quantum_toffoli(ctl,2*width+2,L,reg);
|
||||||
|
emul(a%N, L, width, reg);
|
||||||
|
quantum_toffoli(ctl,2*width+2,L,reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void mul_mod_n(int N, int a, int ctl, int width, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
muln(N,a,ctl,width,reg);
|
||||||
|
|
||||||
|
quantum_swaptheleads_omuln_controlled(ctl, width, reg);
|
||||||
|
|
||||||
|
muln_inv(N,a,ctl,width,reg);
|
||||||
|
|
||||||
|
}
|
||||||
15
omuln.h
Normal file
15
omuln.h
Normal file
@@ -0,0 +1,15 @@
|
|||||||
|
#ifndef __OMULN_H
|
||||||
|
|
||||||
|
#define __OMULN_H
|
||||||
|
|
||||||
|
#include "qureg.h"
|
||||||
|
|
||||||
|
void emul(int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
void muln(int, int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
void muln_inv(int, int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
void mul_mod_n(int, int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
#endif
|
||||||
49
qft.c
Normal file
49
qft.c
Normal file
@@ -0,0 +1,49 @@
|
|||||||
|
/* qft.c: Quantum Fourier Transform
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "gates.h"
|
||||||
|
#include "qureg.h"
|
||||||
|
|
||||||
|
/* Perform a QFT on a quantum register. This is done by application of
|
||||||
|
conditional phase shifts and hadamard gates. At the end, the
|
||||||
|
position of the bits is reversed. */
|
||||||
|
|
||||||
|
void quantum_qft(int width, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i, j;
|
||||||
|
|
||||||
|
for(i=width-1; i>=0; i--)
|
||||||
|
{
|
||||||
|
for(j=width-1; j>i; j--)
|
||||||
|
quantum_cond_phase(j, i, reg);
|
||||||
|
|
||||||
|
quantum_hadamard(i, reg);
|
||||||
|
}
|
||||||
|
|
||||||
|
for(i=0; i<width/2; i++)
|
||||||
|
{
|
||||||
|
quantum_cnot(i, width-i-1, reg);
|
||||||
|
quantum_cnot(width-i-1, i, reg);
|
||||||
|
quantum_cnot(i, width-i-1, reg);
|
||||||
|
}
|
||||||
|
}
|
||||||
30
qft.h
Normal file
30
qft.h
Normal file
@@ -0,0 +1,30 @@
|
|||||||
|
/* qft.c: Declarations for qft.c
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __QFT_H
|
||||||
|
|
||||||
|
#define __QFT_H
|
||||||
|
|
||||||
|
extern void quantum_qft(int width, quantum_reg *reg);
|
||||||
|
|
||||||
|
#endif
|
||||||
117
quantum.h.in
Normal file
117
quantum.h.in
Normal file
@@ -0,0 +1,117 @@
|
|||||||
|
/* quantum.h: Header file for libquantum
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __QUANTUM_H
|
||||||
|
|
||||||
|
#define __QUANTUM_H
|
||||||
|
|
||||||
|
#define COMPLEX_FLOAT @CF_TYPE@
|
||||||
|
#define MAX_UNSIGNED @MU_TYPE@
|
||||||
|
|
||||||
|
/* A ROWS x COLS matrix with complex elements */
|
||||||
|
|
||||||
|
struct quantum_matrix_struct {
|
||||||
|
int rows;
|
||||||
|
int cols;
|
||||||
|
COMPLEX_FLOAT *t;
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct quantum_matrix_struct quantum_matrix;
|
||||||
|
|
||||||
|
struct quantum_reg_node_struct
|
||||||
|
{
|
||||||
|
COMPLEX_FLOAT amplitude; /* alpha_j */
|
||||||
|
MAX_UNSIGNED state; /* j */
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct quantum_reg_node_struct quantum_reg_node;
|
||||||
|
|
||||||
|
/* One element of the hash table */
|
||||||
|
|
||||||
|
struct quantum_reg_hash_struct
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
struct quantum_reg_hash_struct *next;
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct quantum_reg_hash_struct quantum_reg_hash;
|
||||||
|
|
||||||
|
/* The quantum register */
|
||||||
|
|
||||||
|
struct quantum_reg_struct
|
||||||
|
{
|
||||||
|
int width; /* number of qubits in the qureg */
|
||||||
|
int size; /* number of non-zero vectors */
|
||||||
|
int hashw; /* width of the hash array */
|
||||||
|
quantum_reg_node *node;
|
||||||
|
quantum_reg_hash **hash;
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct quantum_reg_struct quantum_reg;
|
||||||
|
|
||||||
|
extern quantum_reg quantum_new_qureg(MAX_UNSIGNED initval, int width);
|
||||||
|
extern void quantum_delete_qureg(quantum_reg *reg);
|
||||||
|
extern void quantum_print_qureg(quantum_reg reg);
|
||||||
|
extern void quantum_addscratch(int bits, quantum_reg *reg);
|
||||||
|
|
||||||
|
extern void quantum_cnot(int, int, quantum_reg *);
|
||||||
|
extern void quantum_toffoli(int, int, int, quantum_reg *);
|
||||||
|
extern void quantum_X_gate(int, quantum_reg *);
|
||||||
|
extern void quantum_Y_gate(int a, quantum_reg *reg);
|
||||||
|
extern void quantum_Z_gate(int a, quantum_reg *reg);
|
||||||
|
extern void quantum_gate1(quantum_matrix m, int a, quantum_reg *reg);
|
||||||
|
extern void quantum_r_x(int a, float gamma, quantum_reg *reg);
|
||||||
|
extern void quantum_r_y(int a, float gamma, quantum_reg *reg);
|
||||||
|
extern void quantum_phase_kick(int a, float gamma, quantum_reg *reg);
|
||||||
|
extern void quantum_hadamard(int a, quantum_reg *reg);
|
||||||
|
extern void quantum_walsh(int a, quantum_reg *reg);
|
||||||
|
extern void quantum_cond_phase(int a, int b, quantum_reg *reg);
|
||||||
|
extern int quantum_gate_counter(int inc);
|
||||||
|
|
||||||
|
extern void quantum_qft(int width, quantum_reg *reg);
|
||||||
|
|
||||||
|
extern void quantum_exp_mod_n(int, int, int, int, quantum_reg *);
|
||||||
|
|
||||||
|
extern MAX_UNSIGNED quantum_measure(quantum_reg reg);
|
||||||
|
extern int quantum_bmeasure(int pos, quantum_reg *reg);
|
||||||
|
|
||||||
|
extern quantum_matrix quantum_new_matrix(int ,int );
|
||||||
|
extern void quantum_delete_matrix(quantum_matrix *m);
|
||||||
|
|
||||||
|
extern int quantum_ipow(int a, int b);
|
||||||
|
extern int quantum_gcd(int u, int v);
|
||||||
|
extern void quantum_cancel(int *a, int *b);
|
||||||
|
extern void quantum_frac_approx(int *a, int *b, int width);
|
||||||
|
extern int quantum_getwidth(int n);
|
||||||
|
|
||||||
|
extern float quantum_prob(COMPLEX_FLOAT a);
|
||||||
|
|
||||||
|
extern void quantum_set_decoherence(float lambda);
|
||||||
|
extern void quantum_decohere(quantum_reg *reg);
|
||||||
|
|
||||||
|
extern void quantum_add_hash(MAX_UNSIGNED a, int pos, quantum_reg *reg);
|
||||||
|
|
||||||
|
extern quantum_reg quantum_matrix2qureg(quantum_matrix *m, int width);
|
||||||
|
extern quantum_matrix quantum_qureg2matrix(quantum_reg reg);
|
||||||
|
|
||||||
|
#endif
|
||||||
337
qureg.c
Normal file
337
qureg.c
Normal file
@@ -0,0 +1,337 @@
|
|||||||
|
/* qureg.c: Quantum register management
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <time.h>
|
||||||
|
|
||||||
|
#include "matrix.h"
|
||||||
|
#include "qureg.h"
|
||||||
|
#include "config.h"
|
||||||
|
#include "complex.h"
|
||||||
|
|
||||||
|
/* Convert a vector to a quantum register */
|
||||||
|
|
||||||
|
quantum_reg
|
||||||
|
quantum_matrix2qureg(quantum_matrix *m, int width)
|
||||||
|
{
|
||||||
|
quantum_reg reg;
|
||||||
|
int i, j, size=0;
|
||||||
|
|
||||||
|
if(m->cols != 1)
|
||||||
|
{
|
||||||
|
printf("Error! Cannot convert a multi-column-matrix (%i)!\n", m->cols);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
reg.width = width;
|
||||||
|
|
||||||
|
/* Determine the size of the quantum register */
|
||||||
|
|
||||||
|
for(i=0; i<m->rows; i++)
|
||||||
|
{
|
||||||
|
if(m->t[i])
|
||||||
|
size++;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Allocate the required memory */
|
||||||
|
|
||||||
|
reg.size = size;
|
||||||
|
reg.hashw = width + 2;
|
||||||
|
|
||||||
|
reg.node = calloc(size, sizeof(quantum_reg_node));
|
||||||
|
if(!reg.node)
|
||||||
|
{
|
||||||
|
printf("Not enough memory for %i-sized qubit!\n", size);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
quantum_memman(size * sizeof(quantum_reg_node));
|
||||||
|
|
||||||
|
/* Allocate the hash table */
|
||||||
|
|
||||||
|
reg.hash = calloc(1 << reg.hashw, sizeof(quantum_reg_hash *));
|
||||||
|
if(!reg.hash)
|
||||||
|
{
|
||||||
|
printf("Not enough memory for %i-sized hash!\n", 1 << reg.hashw);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
quantum_memman((1 << reg.hashw) * sizeof(quantum_reg_hash *));
|
||||||
|
|
||||||
|
/* Copy the nonzero amplitudes of the vector into the quantum
|
||||||
|
register */
|
||||||
|
|
||||||
|
for(i=0, j=0; i<m->rows; i++)
|
||||||
|
{
|
||||||
|
if(m->t[i])
|
||||||
|
{
|
||||||
|
reg.node[j].state = i;
|
||||||
|
reg.node[j].amplitude = m->t[i];
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Initialize the PRNG */
|
||||||
|
|
||||||
|
srandom(time(0));
|
||||||
|
|
||||||
|
return reg;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Create a new quantum register from scratch */
|
||||||
|
|
||||||
|
quantum_reg
|
||||||
|
quantum_new_qureg(MAX_UNSIGNED initval, int width)
|
||||||
|
{
|
||||||
|
quantum_reg reg;
|
||||||
|
|
||||||
|
reg.width = width;
|
||||||
|
reg.size = 1;
|
||||||
|
reg.hashw = width + 2;
|
||||||
|
|
||||||
|
/* Allocate memory for 1 base state */
|
||||||
|
|
||||||
|
reg.node = calloc(1, sizeof(quantum_reg_node));
|
||||||
|
if(!reg.node)
|
||||||
|
{
|
||||||
|
printf("Not enough memory for %i-sized qubit!\n", 1);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
quantum_memman(sizeof(quantum_reg_node));
|
||||||
|
|
||||||
|
/* Allocate the hash table */
|
||||||
|
|
||||||
|
reg.hash = calloc(1 << reg.hashw, sizeof(quantum_reg_hash *));
|
||||||
|
if(!reg.hash)
|
||||||
|
{
|
||||||
|
printf("Not enough memory for %i-sized hash!\n", 1 << reg.hashw);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
quantum_memman((1 << reg.hashw) * sizeof(quantum_reg_hash *));
|
||||||
|
|
||||||
|
/* Initialize the quantum register */
|
||||||
|
|
||||||
|
reg.node[0].state = initval;
|
||||||
|
reg.node[0].amplitude = 1;
|
||||||
|
|
||||||
|
/* Initialize the PRNG */
|
||||||
|
|
||||||
|
srandom(time(0));
|
||||||
|
|
||||||
|
return reg;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Convert a quantum register to a vector */
|
||||||
|
|
||||||
|
quantum_matrix
|
||||||
|
quantum_qureg2matrix(quantum_reg reg)
|
||||||
|
{
|
||||||
|
quantum_matrix m;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
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;
|
||||||
|
|
||||||
|
return m;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Delete a quantum register. Note that the hash table is still
|
||||||
|
alive. */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_delete_qureg(quantum_reg *reg)
|
||||||
|
{
|
||||||
|
free(reg->node);
|
||||||
|
quantum_memman(-reg->size * sizeof(quantum_reg_node));
|
||||||
|
reg->node = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Print the contents of a quantum register to stdout */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_print_qureg(quantum_reg reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=0; i<reg.size; i++)
|
||||||
|
{
|
||||||
|
printf("%f %+fi|%lli>\n", quantum_real(reg.node[i].amplitude),
|
||||||
|
quantum_imag(reg.node[i].amplitude), reg.node[i].state);
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Print the output of the modular exponentation algorithm */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_print_expn(quantum_reg reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i=0; i<reg.size; i++)
|
||||||
|
{
|
||||||
|
printf("%i: %lli\n", i, reg.node[i].state - i * (1 << (reg.width / 2)));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Add additional space to a qureg. It is initialized to zero and can
|
||||||
|
be used as scratch space. Note that the space gets added at the LSB */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_addscratch(int bits, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i, oldwidth;
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Add an element to the hash table */
|
||||||
|
|
||||||
|
void
|
||||||
|
quantum_add_hash(MAX_UNSIGNED a, int pos, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
quantum_reg_hash *p;
|
||||||
|
|
||||||
|
i = quantum_hash64(a, reg->hashw);
|
||||||
|
|
||||||
|
p = calloc(1, sizeof(quantum_reg_hash));
|
||||||
|
if(!p)
|
||||||
|
{
|
||||||
|
printf("Not enough memory for hash element!\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
quantum_memman(sizeof(quantum_reg_hash));
|
||||||
|
|
||||||
|
p->i = pos;
|
||||||
|
p->next = reg->hash[i];
|
||||||
|
|
||||||
|
reg->hash[i] = p;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Remove an element from the hash table */
|
||||||
|
|
||||||
|
void
|
||||||
|
delete_hash(MAX_UNSIGNED a, int pos, quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
quantum_reg_hash *p, *q=0;
|
||||||
|
|
||||||
|
i = quantum_hash64(a, reg->hashw);
|
||||||
|
|
||||||
|
p = reg->hash[i];
|
||||||
|
|
||||||
|
while(p->i != pos)
|
||||||
|
{
|
||||||
|
q = p;
|
||||||
|
p = p->next;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(q)
|
||||||
|
{
|
||||||
|
q->next = p->next;
|
||||||
|
free(p);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if(p)
|
||||||
|
{
|
||||||
|
reg->hash[i] = p->next;
|
||||||
|
free(p);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
reg->hash[i] = 0;
|
||||||
|
free(reg->hash[i]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Print the hash table to stdout and test if the hash table is
|
||||||
|
corrupted */
|
||||||
|
|
||||||
|
void
|
||||||
|
print_hash(quantum_reg reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
quantum_reg_hash *p;
|
||||||
|
char *done;
|
||||||
|
|
||||||
|
done = calloc(reg.size, sizeof(char));
|
||||||
|
if(!done)
|
||||||
|
{
|
||||||
|
printf("Not enough memory for %i bytes array!\n",
|
||||||
|
(reg.size)*sizeof(char));
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
for(i=0; i < (1 << reg.hashw); i++)
|
||||||
|
{
|
||||||
|
printf("%i: ", i);
|
||||||
|
|
||||||
|
if(reg.hash[i])
|
||||||
|
{
|
||||||
|
p = reg.hash[i];
|
||||||
|
|
||||||
|
while(p->next)
|
||||||
|
{
|
||||||
|
printf("%llu ", reg.node[p->i].state);
|
||||||
|
if(quantum_hash64(reg.node[p->i].state, reg.hashw) != i)
|
||||||
|
printf(" Corrupted hash table!\n... ");
|
||||||
|
done[p->i] = 1;
|
||||||
|
p = p->next;
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("%llu", reg.node[p->i].state);
|
||||||
|
if(quantum_hash64(reg.node[p->i].state, reg.hashw) != i)
|
||||||
|
printf(" Corrupted hash table!");
|
||||||
|
done[p->i] = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Test if there are elements in the quantum register which are not
|
||||||
|
in the hash table */
|
||||||
|
|
||||||
|
for(i=0; i<reg.size; i++)
|
||||||
|
{
|
||||||
|
if(!done[i])
|
||||||
|
printf("Corrupted hash table: %llu is detached!\n", reg.node[i].state);
|
||||||
|
}
|
||||||
|
|
||||||
|
free(done);
|
||||||
|
}
|
||||||
153
qureg.h
Normal file
153
qureg.h
Normal file
@@ -0,0 +1,153 @@
|
|||||||
|
/* qureg.h: Declarations for qureg.c and inline hashing functions
|
||||||
|
|
||||||
|
Copyright 2003 Bjoern Butscher, Hendrik Weimer
|
||||||
|
|
||||||
|
This file is part of libquantum
|
||||||
|
|
||||||
|
libquantum is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published
|
||||||
|
by the Free Software Foundation; either version 2 of the License,
|
||||||
|
or (at your option) any later version.
|
||||||
|
|
||||||
|
libquantum is distributed in the hope that it will be useful, but
|
||||||
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||||
|
General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with libquantum; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||||
|
USA
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __QUREG_H
|
||||||
|
|
||||||
|
#define __QUREG_H
|
||||||
|
|
||||||
|
#include <sys/types.h>
|
||||||
|
|
||||||
|
#include "config.h"
|
||||||
|
#include "matrix.h"
|
||||||
|
|
||||||
|
/* Representation of a base state of a quantum register: alpha_j |j> */
|
||||||
|
|
||||||
|
struct quantum_reg_node_struct
|
||||||
|
{
|
||||||
|
COMPLEX_FLOAT amplitude; /* alpha_j */
|
||||||
|
MAX_UNSIGNED state; /* j */
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct quantum_reg_node_struct quantum_reg_node;
|
||||||
|
|
||||||
|
/* One element of the hash table */
|
||||||
|
|
||||||
|
struct quantum_reg_hash_struct
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
struct quantum_reg_hash_struct *next;
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct quantum_reg_hash_struct quantum_reg_hash;
|
||||||
|
|
||||||
|
/* The quantum register */
|
||||||
|
|
||||||
|
struct quantum_reg_struct
|
||||||
|
{
|
||||||
|
int width; /* number of qubits in the qureg */
|
||||||
|
int size; /* number of non-zero vectors */
|
||||||
|
int hashw; /* width of the hash array */
|
||||||
|
quantum_reg_node *node;
|
||||||
|
quantum_reg_hash **hash;
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef struct quantum_reg_struct quantum_reg;
|
||||||
|
|
||||||
|
extern quantum_reg quantum_matrix2qureg(quantum_matrix *m, int width);
|
||||||
|
extern quantum_reg quantum_new_qureg(MAX_UNSIGNED initval, int width);
|
||||||
|
extern quantum_matrix quantum_qureg2matrix(quantum_reg reg);
|
||||||
|
extern void quantum_delete_qureg(quantum_reg *reg);
|
||||||
|
|
||||||
|
extern void quantum_print_qureg(quantum_reg reg);
|
||||||
|
extern void quantum_print_expn(quantum_reg reg);
|
||||||
|
|
||||||
|
extern void quantum_addscratch(int bits, quantum_reg *reg);
|
||||||
|
|
||||||
|
extern void quantum_add_hash(MAX_UNSIGNED a, int pos, quantum_reg *reg);
|
||||||
|
extern void quantum_delete_hash(MAX_UNSIGNED a, int pos, quantum_reg *reg);
|
||||||
|
extern void quantum_print_hash(quantum_reg reg);
|
||||||
|
|
||||||
|
/* Our 64-bit multiplicative hash function */
|
||||||
|
|
||||||
|
static inline unsigned int
|
||||||
|
quantum_hash64(MAX_UNSIGNED key, int width)
|
||||||
|
{
|
||||||
|
unsigned int k32;
|
||||||
|
|
||||||
|
k32 = (key & 0xFFFFFFFF) ^ (key >> 32);
|
||||||
|
|
||||||
|
k32 *= 0x9e370001UL;
|
||||||
|
k32 = k32 >> (32-width);
|
||||||
|
|
||||||
|
return k32;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Get the position of a given base state via the hash table */
|
||||||
|
|
||||||
|
static inline int
|
||||||
|
quantum_get_state(MAX_UNSIGNED a, quantum_reg reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
quantum_reg_hash *p;
|
||||||
|
|
||||||
|
i = quantum_hash64(a, reg.hashw);
|
||||||
|
|
||||||
|
if(reg.hash[i])
|
||||||
|
{
|
||||||
|
p = reg.hash[i];
|
||||||
|
|
||||||
|
do
|
||||||
|
{
|
||||||
|
if(reg.node[p->i].state == a)
|
||||||
|
return p->i;
|
||||||
|
if(p->next)
|
||||||
|
p = p->next;
|
||||||
|
} while(p->next);
|
||||||
|
|
||||||
|
if(reg.node[p->i].state == a)
|
||||||
|
return p->i;
|
||||||
|
}
|
||||||
|
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Update an element of the hash table */
|
||||||
|
|
||||||
|
static inline void
|
||||||
|
quantum_change_hash(MAX_UNSIGNED a, int oldpos, MAX_UNSIGNED b, int pos,
|
||||||
|
quantum_reg *reg)
|
||||||
|
{
|
||||||
|
int i, j;
|
||||||
|
quantum_reg_hash *p, *q=0;
|
||||||
|
|
||||||
|
i = quantum_hash64(a, reg->hashw);
|
||||||
|
|
||||||
|
p = reg->hash[i];
|
||||||
|
q = reg->hash[i];
|
||||||
|
j = p->i;
|
||||||
|
|
||||||
|
while(p->i != oldpos)
|
||||||
|
p = p->next;
|
||||||
|
|
||||||
|
p->i = j;
|
||||||
|
reg->hash[i] = q->next;
|
||||||
|
|
||||||
|
i = quantum_hash64(b, reg->hashw);
|
||||||
|
|
||||||
|
q->next = reg->hash[i];
|
||||||
|
reg->hash[i] = q;
|
||||||
|
q->i = pos;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
125
shor.c
Normal file
125
shor.c
Normal file
@@ -0,0 +1,125 @@
|
|||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <math.h>
|
||||||
|
#include <time.h>
|
||||||
|
|
||||||
|
#include <quantum.h>
|
||||||
|
|
||||||
|
int main(int argc, char **argv) {
|
||||||
|
|
||||||
|
quantum_reg qr;
|
||||||
|
int i;
|
||||||
|
int width, swidth;
|
||||||
|
int x;
|
||||||
|
int N;
|
||||||
|
int c,q,a,b, factor;
|
||||||
|
|
||||||
|
srandom(time(0));
|
||||||
|
|
||||||
|
if(argc==1)
|
||||||
|
{
|
||||||
|
printf("Usage: sim [number]\n\n");
|
||||||
|
return 3;
|
||||||
|
}
|
||||||
|
|
||||||
|
N=atoi(argv[1]);
|
||||||
|
|
||||||
|
if(N<15)
|
||||||
|
{
|
||||||
|
printf("Invalid number\n\n");
|
||||||
|
return 3;
|
||||||
|
}
|
||||||
|
|
||||||
|
width=quantum_getwidth(N*N);
|
||||||
|
swidth=quantum_getwidth(N);
|
||||||
|
|
||||||
|
printf("N = %i, %i qubits required\n", N, width+3*swidth+2);
|
||||||
|
|
||||||
|
do
|
||||||
|
{
|
||||||
|
x = random() % N;
|
||||||
|
} while((quantum_gcd(N, x) > 1) || (x < 2));
|
||||||
|
|
||||||
|
printf("Random seed: %i\n", x);
|
||||||
|
|
||||||
|
qr=quantum_new_qureg(0, width);
|
||||||
|
|
||||||
|
for(i=0;i<width;i++)
|
||||||
|
quantum_hadamard(i, &qr);
|
||||||
|
|
||||||
|
quantum_addscratch(3*swidth+2, &qr);
|
||||||
|
|
||||||
|
quantum_exp_mod_n(N, x, width, swidth, &qr);
|
||||||
|
|
||||||
|
for(i=0;i<3*swidth+2;i++)
|
||||||
|
{
|
||||||
|
quantum_bmeasure(0, &qr);
|
||||||
|
}
|
||||||
|
|
||||||
|
quantum_qft(width, &qr);
|
||||||
|
|
||||||
|
// quantum_print_qureg(qr);
|
||||||
|
|
||||||
|
c=quantum_measure(qr);
|
||||||
|
|
||||||
|
if(c==-1)
|
||||||
|
{
|
||||||
|
printf("Impossible Measurement!\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
if(c==0)
|
||||||
|
{
|
||||||
|
printf("Measured zero, try again.\n");
|
||||||
|
exit(2);
|
||||||
|
}
|
||||||
|
|
||||||
|
q = 1<<(width);
|
||||||
|
|
||||||
|
printf("Measured %i (%f), ", c, (float)c/q);
|
||||||
|
|
||||||
|
quantum_frac_approx(&c, &q, width);
|
||||||
|
|
||||||
|
printf("fractional approximation is %i/%i.\n", c, q);
|
||||||
|
|
||||||
|
if((q % 2 == 1) && (2*q<(1<<width)))
|
||||||
|
{
|
||||||
|
printf("Odd denominator, trying to expand by 2.\n");
|
||||||
|
q *= 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(q % 2 == 1)
|
||||||
|
{
|
||||||
|
printf("Odd period, try again.\n");
|
||||||
|
exit(2);
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("Possible period is %i.\n", q);
|
||||||
|
|
||||||
|
a = quantum_ipow(x, q/2) + 1 % N;
|
||||||
|
b = quantum_ipow(x, q/2) - 1 % N;
|
||||||
|
|
||||||
|
a = quantum_gcd(N, a);
|
||||||
|
b = quantum_gcd(N, b);
|
||||||
|
|
||||||
|
if(a>b)
|
||||||
|
factor=a;
|
||||||
|
else
|
||||||
|
factor=b;
|
||||||
|
|
||||||
|
if((factor < N) && (factor > 1))
|
||||||
|
{
|
||||||
|
printf("%i = %i * %i\n", N, factor, N/factor);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
printf("Unable to determine factors, try again.\n");
|
||||||
|
exit(2);
|
||||||
|
}
|
||||||
|
|
||||||
|
quantum_delete_qureg(&qr);
|
||||||
|
|
||||||
|
// printf("Memory usage: %i bytes\n", (int )memman(0));
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user