pete
/
abp
1
1
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

Remove CHP for now -- it was only used for testing

master
Pete Shadbolt 8 years ago
parent
1f7fea7399
commit
6ed977ae2b
5 changed files with 1 additions and 1019 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -0
      .gitignore
  2. +0
    -986
      chp/chp.c
  3. +0
    -4
      chp/run.sh
  4. +0
    -18
      chp/setup.py
  5. +0
    -11
      chp/test.py

+ 1
- 0
.gitignore View File

@@ -1,3 +1,4 @@
chp/
.venv .venv
.anders .anders
.noseids .noseids


+ 0
- 986
chp/chp.c View File

@@ -1,986 +0,0 @@
// CHP: CNOT-Hadamard-Phase
// Stabilizer Quantum Computer Simulator
// by Scott Aaronson
// Last modified June 30, 2004

// Thanks to Simon Anders and Andrew Cross for bugfixes



#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <Python.h>
#include <time.h>


#define CNOT 0
#define HADAMARD 1
#define PHASE 2
#define MEASURE 3



struct QProg
// Quantum circuit

{

long n; // # of qubits
long T; // # of gates
char *a; // Instruction opcode
long *b; // Qubit 1
long *c; // Qubit 2 (target for CNOT)
int DISPQSTATE; // whether to print the state (q for final state only, Q for every iteration)
int DISPTIME; // whether to print the execution time
int SILENT; // whether NOT to print measurement results
int DISPPROG; // whether to print instructions being executed as they're executed
int SUPPRESSM; // whether to suppress actual computation of determinate measurement results

};



struct QState

// Quantum state

{

// To save memory and increase speed, the bits are packed 32 to an unsigned long
long n; // # of qubits
unsigned long **x; // (2n+1)*n matrix for stabilizer/destabilizer x bits (there's one "scratch row" at
unsigned long **z; // (2n+1)*n matrix for z bits the bottom)
int *r; // Phase bits: 0 for +1, 1 for i, 2 for -1, 3 for -i. Normally either 0 or 2.
unsigned long pw[32]; // pw[i] = 2^i
long over32; // floor(n/8)+1

};

// Globals
struct QProg *h;
struct QState *q;

void error(int k)

{

if (k==0) printf("\nSyntax: chp [-options] <filename> [input]\n");
if (k==1) printf("\nFile not found\n");
exit(0);

}



void cnot(struct QState *q, long b, long c)

// Apply a CNOT gate with control b and target c

{

long i;
long b5;
long c5;
unsigned long pwb;
unsigned long pwc;

b5 = b>>5;
c5 = c>>5;
pwb = q->pw[b&31];
pwc = q->pw[c&31];
for (i = 0; i < 2*q->n; i++)
{
if (q->x[i][b5]&pwb) q->x[i][c5] ^= pwc;
if (q->z[i][c5]&pwc) q->z[i][b5] ^= pwb;
if ((q->x[i][b5]&pwb) && (q->z[i][c5]&pwc) &&
(q->x[i][c5]&pwc) && (q->z[i][b5]&pwb))
q->r[i] = (q->r[i]+2)%4;
if ((q->x[i][b5]&pwb) && (q->z[i][c5]&pwc) &&
!(q->x[i][c5]&pwc) && !(q->z[i][b5]&pwb))
q->r[i] = (q->r[i]+2)%4;
}

return;

}



void hadamard(struct QState *q, long b)

// Apply a Hadamard gate to qubit b

{

long i;
unsigned long tmp;
long b5;
unsigned long pw;

b5 = b>>5;
pw = q->pw[b&31];
for (i = 0; i < 2*q->n; i++)
{
tmp = q->x[i][b5];
q->x[i][b5] ^= (q->x[i][b5] ^ q->z[i][b5]) & pw;
q->z[i][b5] ^= (q->z[i][b5] ^ tmp) & pw;
if ((q->x[i][b5]&pw) && (q->z[i][b5]&pw)) q->r[i] = (q->r[i]+2)%4;
}

return;

}



void phase(struct QState *q, long b)

// Apply a phase gate (|0>->|0>, |1>->i|1>) to qubit b

{

long i;
long b5;
unsigned long pw;

b5 = b>>5;
pw = q->pw[b&31];
for (i = 0; i < 2*q->n; i++)
{
if ((q->x[i][b5]&pw) && (q->z[i][b5]&pw)) q->r[i] = (q->r[i]+2)%4;
q->z[i][b5] ^= q->x[i][b5]&pw;
}

return;

}



void rowcopy(struct QState *q, long i, long k)

// Sets row i equal to row k

{

long j;

for (j = 0; j < q->over32; j++)
{
q->x[i][j] = q->x[k][j];
q->z[i][j] = q->z[k][j];
}
q->r[i] = q->r[k];

return;

}



void rowswap(struct QState *q, long i, long k)

// Swaps row i and row k

{

rowcopy(q, 2*q->n, k);
rowcopy(q, k, i);
rowcopy(q, i, 2*q->n);

return;

}



void rowset(struct QState *q, long i, long b)

// Sets row i equal to the bth observable (X_1,...X_n,Z_1,...,Z_n)

{

long j;
long b5;
unsigned long b31;

for (j = 0; j < q->over32; j++)
{
q->x[i][j] = 0;
q->z[i][j] = 0;
}
q->r[i] = 0;
if (b < q->n)
{
b5 = b>>5;
b31 = b&31;
q->x[i][b5] = q->pw[b31];
}
else
{
b5 = (b - q->n)>>5;
b31 = (b - q->n)&31;
q->z[i][b5] = q->pw[b31];
}

return;

}



int clifford(struct QState *q, long i, long k)

// Return the phase (0,1,2,3) when row i is LEFT-multiplied by row k

{

long j;
long l;
unsigned long pw;
long e=0; // Power to which i is raised

for (j = 0; j < q->over32; j++)
for (l = 0; l < 32; l++)
{
pw = q->pw[l];
if ((q->x[k][j]&pw) && (!(q->z[k][j]&pw))) // X
{
if ((q->x[i][j]&pw) && (q->z[i][j]&pw)) e++; // XY=iZ
if ((!(q->x[i][j]&pw)) && (q->z[i][j]&pw)) e--; // XZ=-iY
}
if ((q->x[k][j]&pw) && (q->z[k][j]&pw)) // Y
{
if ((!(q->x[i][j]&pw)) && (q->z[i][j]&pw)) e++; // YZ=iX
if ((q->x[i][j]&pw) && (!(q->z[i][j]&pw))) e--; // YX=-iZ
}
if ((!(q->x[k][j]&pw)) && (q->z[k][j]&pw)) // Z
{
if ((q->x[i][j]&pw) && (!(q->z[i][j]&pw))) e++; // ZX=iY
if ((q->x[i][j]&pw) && (q->z[i][j]&pw)) e--; // ZY=-iX
}
}

e = (e+q->r[i]+q->r[k])%4;
if (e>=0) return e;
else return e+4;

}



void rowmult(struct QState *q, long i, long k)

// Left-multiply row i by row k

{

long j;

q->r[i] = clifford(q,i,k);
for (j = 0; j < q->over32; j++)
{
q->x[i][j] ^= q->x[k][j];
q->z[i][j] ^= q->z[k][j];
}

return;

}



void printstate(struct QState *q)

// Print the destabilizer and stabilizer for state q

{

long i;
long j;
long j5;
unsigned long pw;

for (i = 0; i < 2*q->n; i++)
{
if (i == q->n)
{
printf("\n");
for (j = 0; j < q->n+1; j++)
printf("-");
}
if (q->r[i]==2) printf("\n-");
else printf("\n+");
for (j = 0; j < q->n; j++)
{
j5 = j>>5;
pw = q->pw[j&31];
if ((!(q->x[i][j5]&pw)) && (!(q->z[i][j5]&pw))) printf("I");
if ((q->x[i][j5]&pw) && (!(q->z[i][j5]&pw))) printf("X");
if ((q->x[i][j5]&pw) && (q->z[i][j5]&pw)) printf("Y");
if ((!(q->x[i][j5]&pw)) && (q->z[i][j5]&pw)) printf("Z");
}
}
printf("\n");

return;

}



int measure(struct QState *q, long b, int sup)

// Measure qubit b
// Return 0 if outcome would always be 0
// 1 if outcome would always be 1
// 2 if outcome was random and 0 was chosen
// 3 if outcome was random and 1 was chosen
// sup: 1 if determinate measurement results should be suppressed, 0 otherwise

{

int ran = 0;
long i;
long p; // pivot row in stabilizer
long m; // pivot row in destabilizer
long b5;
unsigned long pw;

b5 = b>>5;
pw = q->pw[b&31];
for (p = 0; p < q->n; p++) // loop over stabilizer generators
{
if (q->x[p+q->n][b5]&pw) ran = 1; // if a Zbar does NOT commute with Z_b (the
if (ran) break; // operator being measured), then outcome is random
}

// If outcome is indeterminate
if (ran)
{
rowcopy(q, p, p + q->n); // Set Xbar_p := Zbar_p
rowset(q, p + q->n, b + q->n); // Set Zbar_p := Z_b
q->r[p + q->n] = 2*(rand()%2); // moment of quantum randomness
for (i = 0; i < 2*q->n; i++) // Now update the Xbar's and Zbar's that don't commute with
if ((i!=p) && (q->x[i][b5]&pw)) // Z_b
rowmult(q, i, p);
if (q->r[p + q->n]) return 3;
else return 2;
}

// If outcome is determinate
if ((!ran) && (!sup))
{
for (m = 0; m < q->n; m++) // Before we were checking if stabilizer generators commute
if (q->x[m][b5]&pw) break; // with Z_b; now we're checking destabilizer generators
rowcopy(q, 2*q->n, m + q->n);
for (i = m+1; i < q->n; i++)
if (q->x[i][b5]&pw)
rowmult(q, 2*q->n, i + q->n);
if (q->r[2*q->n]) return 1;
else return 0;
/*for (i = m+1; i < q->n; i++)
if (q->x[i][b5]&pw)
{
rowmult(q, m + q->n, i + q->n);
rowmult(q, i, m);
}
return (int)q->r[m + q->n];*/
}

return 0;

}



long gaussian(struct QState *q)

// Do Gaussian elimination to put the stabilizer generators in the following form:
// At the top, a minimal set of generators containing X's and Y's, in "quasi-upper-triangular" form.
// (Return value = number of such generators = log_2 of number of nonzero basis states)
// At the bottom, generators containing Z's only in quasi-upper-triangular form.

{

long i = q->n;
long k;
long k2;
long j;
long j5;
long g; // Return value
unsigned long pw;

for (j = 0; j < q->n; j++)
{
j5 = j>>5;
pw = q->pw[j&31];
for (k = i; k < 2*q->n; k++) // Find a generator containing X in jth column
if (q->x[k][j5]&pw) break;
if (k < 2*q->n)
{
rowswap(q, i, k);
rowswap(q, i-q->n, k-q->n);
for (k2 = i+1; k2 < 2*q->n; k2++)
if (q->x[k2][j5]&pw)
{
rowmult(q, k2, i); // Gaussian elimination step
rowmult(q, i-q->n, k2-q->n);
}
i++;
}
}
g = i - q->n;

for (j = 0; j < q->n; j++)
{
j5 = j>>5;
pw = q->pw[j&31];
for (k = i; k < 2*q->n; k++) // Find a generator containing Z in jth column
if (q->z[k][j5]&pw) break;
if (k < 2*q->n)
{
rowswap(q, i, k);
rowswap(q, i-q->n, k-q->n);
for (k2 = i+1; k2 < 2*q->n; k2++)
if (q->z[k2][j5]&pw)
{
rowmult(q, k2, i);
rowmult(q, i-q->n, k2-q->n);
}
i++;
}
}

return g;

}



long innerprod(struct QState *q1, struct QState *q2)

// Returns -1 if q1 and q2 are orthogonal
// Otherwise, returns a nonnegative integer s such that the inner product is (1/sqrt(2))^s

{

return 0;

}



void printbasisstate(struct QState *q)

// Prints the result of applying the Pauli operator in the "scratch space" of q to |0...0>

{

long j;
long j5;
unsigned long pw;
int e = q->r[2*q->n];

for (j = 0; j < q->n; j++)
{
j5 = j>>5;
pw = q->pw[j&31];
if ((q->x[2*q->n][j5]&pw) && (q->z[2*q->n][j5]&pw)) // Pauli operator is "Y"
e = (e+1)%4;
}
if (e==0) printf("\n +|");
if (e==1) printf("\n+i|");
if (e==2) printf("\n -|");
if (e==3) printf("\n-i|");

for (j = 0; j < q->n; j++)
{
j5 = j>>5;
pw = q->pw[j&31];
if (q->x[2*q->n][j5]&pw) printf("1");
else printf("0");
}
printf(">");

return;

}


void dumpbasisstate(struct QState *q, PyObject *output, int index)

// Dumps the result of applying the Pauli operator in the "scratch space" of q to |0...0>

{

long j;
long j5;
unsigned long pw;
int e = q->r[2*q->n];
char buffer[1024];
strcpy(buffer, "");

for (j = 0; j < q->n; j++)
{
j5 = j>>5;
pw = q->pw[j&31];
if ((q->x[2*q->n][j5]&pw) && (q->z[2*q->n][j5]&pw)) // Pauli operator is "Y"
e = (e+1)%4;
}
if (e==0) strcat(buffer, "+|");
if (e==1) strcat(buffer, "+i|");
if (e==2) strcat(buffer, "-|");
if (e==3) strcat(buffer, "-i|");


int key;
key = 0;
for (j = 0; j < q->n; j++)
{
j5 = j>>5;
pw = q->pw[j&31];
if (q->x[2*q->n][j5]&pw) key = key ^ (1 << j);
}

PyDict_SetItem(output, Py_BuildValue("i", key), Py_BuildValue("i", e));
return;
}



void seed(struct QState *q, long g)

// Finds a Pauli operator P such that the basis state P|0...0> occurs with nonzero amplitude in q, and
// writes P to the scratch space of q. For this to work, Gaussian elimination must already have been
// performed on q. g is the return value from gaussian(q).

{

long i;
long j;
long j5;
unsigned long pw;
int f;
long min=0;

q->r[2*q->n] = 0;
for (j = 0; j < q->over32; j++)
{
q->x[2*q->n][j] = 0; // Wipe the scratch space clean
q->z[2*q->n][j] = 0;
}
for (i = 2*q->n - 1; i >= q->n + g; i--)
{
f = q->r[i];
for (j = q->n - 1; j >= 0; j--)
{
j5 = j>>5;
pw = q->pw[j&31];
if (q->z[i][j5]&pw)
{
min = j;
if (q->x[2*q->n][j5]&pw) f = (f+2)%4;
}
}
if (f==2)
{
j5 = min>>5;
pw = q->pw[min&31];
q->x[2*q->n][j5] ^= pw; // Make the seed consistent with the ith equation
}
}

return;

}

static char act_hadamard_docs[] = "act_hadamard(): Do a Hadamard";
static PyObject* act_hadamard(PyObject* self, PyObject* args)
{
int which;
if (!PyArg_ParseTuple(args, "i", &which)) { return NULL; }
hadamard(q, which);

Py_INCREF(Py_None);
return Py_None;
}

static char act_phase_docs[] = "act_phase(): Do a phase";
static PyObject* act_phase(PyObject* self, PyObject* args)
{
int which;
if (!PyArg_ParseTuple(args, "i", &which)) { return NULL; }
phase(q, which);

Py_INCREF(Py_None);
return Py_None;
}


static char act_cnot_docs[] = "act_cnot(): Do a CNOT";
static PyObject* act_cnot(PyObject* self, PyObject* args)
{
int a, b;
if (!PyArg_ParseTuple(args, "ii", &a, &b)) { return NULL; }
cnot(q, a, b);

Py_INCREF(Py_None);
return Py_None;
}


static char act_cz_docs[] = "act_cz(): Do a cz";
static PyObject* act_cz(PyObject* self, PyObject* args)
{
int a, b;
if (!PyArg_ParseTuple(args, "ii", &a, &b)) { return NULL; }
hadamard(q, b);
cnot(q, a, b);
hadamard(q, b);

Py_INCREF(Py_None);
return Py_None;
}




static char get_ket_docs[] = "get_ket(): Get the state vector";
static PyObject* get_ket(PyObject* self, PyObject* noarg)

// Print the state in ket notation (warning: could be huge!)

{
long g; // log_2 of number of nonzero basis states
unsigned long t;
unsigned long t2;
long i;

g = gaussian(q);

PyObject *output = PyDict_New();
if (g > 30) { return output; }

seed(q, g);
dumpbasisstate(q, output, 0);
for (t = 0; t < q->pw[g]-1; t++)
{
t2 = t ^ (t+1);
for (i = 0; i < g; i++)
if (t2 & q->pw[i])
rowmult(q, 2*q->n, q->n + i);
dumpbasisstate(q, output, t+1);
}
return output;
}

void printket(struct QState *q)

// Print the state in ket notation (warning: could be huge!)

{

long g; // log_2 of number of nonzero basis states
unsigned long t;
unsigned long t2;
long i;

g = gaussian(q);
printf("\n2^%ld nonzero basis states", g);
if (g > 31)
{
printf("\nState is WAY too big to print");
return;
}

seed(q, g);
printbasisstate(q);
for (t = 0; t < q->pw[g]-1; t++)
{
t2 = t ^ (t+1);
for (i = 0; i < g; i++)
if (t2 & q->pw[i])
rowmult(q, 2*q->n, q->n + i);
printbasisstate(q);
}
printf("\n");

return;

}



void runprog(struct QProg *h, struct QState *q)

// Simulate the quantum circuit

{

long t;
int m; // measurement result
time_t tp;
double dt;
char mvirgin = 1;

time(&tp);
for (t = 0; t < h->T; t++)
{
if (h->a[t]==CNOT) cnot(q,h->b[t],h->c[t]);
if (h->a[t]==HADAMARD) hadamard(q,h->b[t]);
if (h->a[t]==PHASE) phase(q,h->b[t]);
if (h->a[t]==MEASURE)
{
if (mvirgin && h->DISPTIME)
{
dt = difftime(time(0),tp);
printf("\nGate time: %lf seconds", dt);
printf("\nTime per 10000 gates: %lf seconds", dt*10000.0f/(h->T - h->n));
time(&tp);
}
mvirgin = 0;
m = measure(q,h->b[t],h->SUPPRESSM);
if (!h->SILENT)
{
printf("\nOutcome of measuring qubit %ld: ", h->b[t]);
if (m>1) printf("%d (random)", m-2);
else printf("%d", m);
}
}
if (h->DISPPROG)
{
if (h->a[t]==CNOT) printf("\nCNOT %ld->%ld", h->b[t], h->c[t]);
if (h->a[t]==HADAMARD) printf("\nHadamard %ld", h->b[t]);
if (h->a[t]==PHASE) printf("\nPhase %ld", h->b[t]);
}
}
printf("\n");
if (h->DISPTIME)
{
dt = difftime(time(0),tp);
printf("\nMeasurement time: %lf seconds", dt);
printf("\nTime per 10000 measurements: %lf seconds\n", dt*10000.0f/h->n);
}
if (h->DISPQSTATE)
{
printf("\nFinal state:");
printstate(q);
gaussian(q);
printstate(q);
printket(q);
}
return;

}



void preparestate(struct QState *q, char *s)

// Prepare the initial state's "input"

{

long l;
long b;

l = strlen(s);
for (b = 0; b < l; b++)
{
if (s[b]=='Z')
{
hadamard(q,b);
phase(q,b);
phase(q,b);
hadamard(q,b);
}
if (s[b]=='x') hadamard(q,b);
if (s[b]=='X')
{
hadamard(q,b);
phase(q,b);
phase(q,b);
}
if (s[b]=='y')
{
hadamard(q,b);
phase(q,b);
}
if (s[b]=='Y')
{
hadamard(q,b);
phase(q,b);
phase(q,b);
phase(q,b);
}
}

return;

}



void initstae_(struct QState *q, long n, char *s)

// Initialize state q to have n qubits, and input specified by s

{

long i;
long j;

q->n = n;
q->x = malloc((2*q->n + 1) * sizeof(unsigned long*));
q->z = malloc((2*q->n + 1) * sizeof(unsigned long*));
q->r = malloc((2*q->n + 1) * sizeof(int));
q->over32 = (q->n>>5) + 1;
q->pw[0] = 1;
for (i = 1; i < 32; i++)
q->pw[i] = 2*q->pw[i-1];
for (i = 0; i < 2*q->n + 1; i++)
{
q->x[i] = malloc(q->over32 * sizeof(unsigned long));
q->z[i] = malloc(q->over32 * sizeof(unsigned long));
for (j = 0; j < q->over32; j++)
{
q->x[i][j] = 0;
q->z[i][j] = 0;
}
if (i < q->n)
q->x[i][i>>5] = q->pw[i&31];
else if (i < 2*q->n)
{
j = i-q->n;
q->z[i][j>>5] = q->pw[j&31];
}
q->r[i] = 0;
}
if (s) preparestate(q, s);

return;

}



void readprog(struct QProg *h, char *fn, char *params)

// Read a quantum circuit from filename fn, with optional parameters params

{

long t;
char fn2[255];
FILE *fp;
char c=0;
long val;
long l;

h->DISPQSTATE = 0;
h->DISPTIME = 0;
h->SILENT = 0;
h->DISPPROG = 0;
h->SUPPRESSM = 0;
if (params)
{
l = strlen(params);
for (t = 1; t < l; t++)
{
if ((params[t]=='q')||(params[t]=='Q')) h->DISPQSTATE = 1;
if ((params[t]=='p')||(params[t]=='P')) h->DISPPROG = 1;
if ((params[t]=='t')||(params[t]=='T')) h->DISPTIME = 1;
if ((params[t]=='s')||(params[t]=='S')) h->SILENT = 1;
if ((params[t]=='m')||(params[t]=='M')) h->SUPPRESSM = 1;
}
}

sprintf(fn2, "%s", fn);
fp = fopen(fn2, "r");
if (!fp)
{
sprintf(fn2, "%s.chp", fn);
fp = fopen(fn2, "r");
if (!fp) error(1);
}
while (!feof(fp)&&(c!='#'))
fscanf(fp, "%c", &c);
if (c!='#') error(2);
h->T = 0;
h->n = 0;
while (!feof(fp))
{
fscanf(fp, "%c", &c);
if ((c=='\r')||(c=='\n'))
continue;
fscanf(fp, "%ld", &val);
if (val+1 > h->n) h->n = val+1;
if ((c=='c')||(c=='C'))
{
fscanf(fp, "%ld", &val);
if (val+1 > h->n) h->n = val+1;
}
h->T++;
}
fclose(fp);
h->a = malloc(h->T * sizeof(char));
h->b = malloc(h->T * sizeof(long));
h->c = malloc(h->T * sizeof(long));
fp = fopen(fn2, "r");
while (!feof(fp)&&(c!='#'))
fscanf(fp, "%c", &c);
t=0;
while (!feof(fp))
{
fscanf(fp, "%c", &c);
if ((c=='\r')||(c=='\n'))
continue;
if ((c=='c')||(c=='C')) h->a[t] = CNOT;
if ((c=='h')||(c=='H')) h->a[t] = HADAMARD;
if ((c=='p')||(c=='P')) h->a[t] = PHASE;
if ((c=='m')||(c=='M')) h->a[t] = MEASURE;
fscanf(fp, "%ld", &h->b[t]);
if (h->a[t]==CNOT) fscanf(fp, "%ld", &h->c[t]);
t++;
}
fclose(fp);

return;

}


static char init_docs[] = "init(nqubits): Initialize with n qubits";
static PyObject* init(PyObject* self, PyObject* args)
{
int nqubits;
if (!PyArg_ParseTuple(args, "i", &nqubits)) { return NULL; }

srand(time(0));

h = malloc(sizeof(struct QProg));
q = malloc(sizeof(struct QState));
initstae_(q,nqubits,NULL);
PyObject *response = Py_BuildValue("i", nqubits);
return response;
}

static PyMethodDef chp_funcs[] = {
{"init", (PyCFunction)init, METH_VARARGS, init_docs},
{"get_ket", (PyCFunction)get_ket, METH_NOARGS, get_ket_docs},
{"act_hadamard", (PyCFunction)act_hadamard, METH_VARARGS, act_hadamard_docs},
{"act_cnot", (PyCFunction)act_cnot, METH_VARARGS, act_cnot_docs},
{"act_cz", (PyCFunction)act_cz, METH_VARARGS, act_cz_docs},
{"act_phase", (PyCFunction)act_phase, METH_VARARGS, act_phase_docs},
{NULL}
};


void initchp(int argc, char **argv)
{
Py_InitModule3("chp", chp_funcs, "CHP");
}


+ 0
- 4
chp/run.sh View File

@@ -1,4 +0,0 @@
#!/bin/bash
gcc -DNDEBUG -g -O3 -Wall -Wno-unused-result -Wstrict-prototypes -fPIC -DMAJOR_VERSION=1 -DMINOR_VERSION=0 -I/usr/include -I/usr/include/python2.7 -c chp.c -o chp.o
gcc -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -Wl,-z,relro -fno-strict-aliasing -DNDEBUG -g -fwrapv -O2 -Wno-unused-result -Wstrict-prototypes -D_FORTIFY_SOURCE=2 -g -fstack-protector --param=ssp-buffer-size=4 -Wformat -Werror=format-security chp.o -o chp.so
python test.py

+ 0
- 18
chp/setup.py View File

@@ -1,18 +0,0 @@
import os
from setuptools import setup, Extension, find_packages

path = "chp.c"
chp = Extension("chp", [path])

extensions = [chp]

setup(
name="chp",
version="0.1",
packages=find_packages(),
ext_modules=extensions,
author="Scott Aaronson & Daniel Gottesman",
description="Ported by Pete Shadbolt",
license="Copyright Scott Aaronson"
)


+ 0
- 11
chp/test.py View File

@@ -1,11 +0,0 @@
import chp
import numpy as np

chp.init(5)
chp.act_hadamard(0)
chp.act_cnot(0, 1)
chp.act_phase(0)

for key, value in chp.get_ket().items():
print bin(key), np.exp(1j * value * np.pi/2).round(2)


Write Preview
Loading…
Cancel
Save