Micro-simulator in C

crates/c/Justfile

@@ -0,0 +1,13 @@
+prefix := `realpath prefix`
+
+export LD_LIBRARY_PATH := env("LD_LIBRARY_PATH", "") + ":" + prefix + "/lib/"
+export LD_DYLD_PATH:= env("LD_DYLD_PATH", "") + ":" + prefix + "/lib/"
+
+install:
+ cargo cinstall --prefix {{prefix}}
+
+example-build name:
+ cd examples/ && make {{name}}
+
+example name: (example-build name)
+ cd examples/ && ./{{name}}

crates/c/README.md

@@ -27,11 +27,11 @@ but you can change this value with any other valid path).
 
 Now move into the `examples/` folder in here.
 
-To compile an example, than use:
+To compile an example, just run:
 
 ```sh
 # from inside `examples/`
-PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$(realpath ../prefix/lib/pkgconfig) make my-example
+make my-example
 ```
 
 and then run the compiled example with the following:
@@ -43,6 +43,26 @@ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(realpath ../prefix/lib/) ./my-example
 LD_DYLD_PATH=$LD_DYLD_PATH:$(realpath ../prefix/lib/) ./my-example
 ```
 
+#### `pkg-config`
+
+To use a custom prefix, change your `PKG_CONFIG_PATH` variable, appending the your
+prefix location:
+
+```sh
+# from inside `examples/`
+PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$(realpath ../prefix/lib/pkgconfig) make my-example
+```
+
+and remove the line exporting this variable in the `Makefile`.
+
+#### Justfile
+
+For people making use of [`just`](https://just.systems/), a `Justfile` is provided. Examples could be run using:
+
+```sh
+just example my-example
+```
+
 ## What's next
 
 We are working to provide reliable internal dependency, and a suitable package for

crates/c/examples/.gitignore

@@ -1 +1,4 @@
-circuit
+draw
+
+libmicrosim.so
+execute

crates/c/examples/Makefile

@@ -1,7 +1,22 @@
+PREFIX=$(shell realpath ../prefix/)
+export PKG_CONFIG_PATH := $(PREFIX)/lib/pkgconfig
+
 CFLAGS=-g -Wall -Wextra $(shell pkg-config --cflags qibo_core_c)
 LDFLAGS=$(shell pkg-config --libs qibo_core_c)
 
 SOURCES=$(wildcard *.c)
 EXECUTABLES=$(patsubst %.c,%,$(SOURCES))
 
+
+libmicrosim.so: microsimulator/microsim.c microsimulator/microsim.h
+ @cp ./microsimulator/microsim.h $(PREFIX)/include/
+ $(CC) $(CFLAGS) -I$(PREFIX)/include $(LDFLAGS) microsimulator/microsim.c -shared -o libmicrosim.so
+ cp libmicrosim.so $(PREFIX)/lib/
+
+CMICROSIM=-I$(PREFIX)/include
+LDMICROSIM=-L$(PREFIX)/lib -lmicrosim
+
+execute: libmicrosim.so execute.c
+ $(CC) $(CFLAGS) $(CMICROSIM) $(LDFLAGS) $(LDMICROSIM) execute.c -o execute
+
 all: $(EXECUTABLES)

crates/c/examples/draw.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <complex.h>
+#include "qibo_core_c.h"
+
+
+int main(int, char *[])
+{
+ qibo_core_circuit *c = qibo_core_circuit_new(5);
+ qibo_core_circuit_add(c, "H", (size_t[]) {0}, 1);
+ qibo_core_circuit_add(c, "X", (size_t[]) {2}, 1);
+ qibo_core_circuit_add(c, "H", (size_t[]) {2}, 1);
+ qibo_core_circuit_add(c, "X", (size_t[]) {3}, 1);
+ qibo_core_circuit_add(c, "CNOT", (size_t[]) {0, 3}, 2);
+
+ printf("%s\n", qibo_core_circuit_draw(c));
+
+ return 0;
+}

crates/c/examples/execute.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <complex.h>
+#include "qibo_core_c.h"
+#include "microsim.h"
+
+
+void print_state(complex double *state, const size_t size) {
+ //const size_t size = sizeof(state) / sizeof(state[0]);
+ for (size_t i=0; i < size; i++) {
+ printf("%ld: %.4f, %.4f\n", i, creal(state[i]), cimag(state[i]));
+ }
+}
+
+
+int main(int, char *[])
+{
+ qibo_core_circuit *c = qibo_core_circuit_new(5);
+ qibo_core_circuit_add(c, "H", (size_t[]) {0}, 1);
+ qibo_core_circuit_add(c, "X", (size_t[]) {2}, 1);
+ qibo_core_circuit_add(c, "H", (size_t[]) {2}, 1);
+ qibo_core_circuit_add(c, "X", (size_t[]) {3}, 1);
+ qibo_core_circuit_add(c, "CNOT", (size_t[]) {0, 3}, 2);
+
+ printf("%s\n\n", qibo_core_circuit_draw(c));
+
+ // Initialize 5-qubit state vector
+ complex double state[32] = { 0 };
+ state[0] = 1;
+
+ // Execute circuit
+ execute_circuit(c, state);
+
+ // Print state vector
+ print_state(state, 32);
+
+ return 0;
+}

crates/c/examples/microsimulator/microsim.c

@@ -0,0 +1,112 @@
+#include <stdio.h>
+#include <complex.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "qibo_core_c.h"
+#include "microsim.h"
+
+// normalization factor
+double const H = 1.0 / sqrt(2);
+// matrices implementing gates
+struct {
+ complex double h[4];
+ complex double x[4];
+ complex double y[4];
+ complex double z[4];
+} const MATRICES = {
+ {H, H, H, -H},
+ {0, 1, 1, 0},
+ {0, -I, I, 0},
+ {1, 0, 0, -1}
+};
+
+// get matrix corresponding to the gate
+complex double const* matrix(const char* gate) {
+ if (strcmp(gate, "H") == 0) {
+ return MATRICES.h;
+ }
+ if (strcmp(gate, "Y") == 0) {
+ return MATRICES.y;
+ }
+ if (strcmp(gate, "Z") == 0) {
+ return MATRICES.z;
+ }
+ return MATRICES.x;
+}
+
+// integer comparison, compatible with qsort
+int compare(const void* a, const void* b) {
+ return (*(int*)a - *(int*)b);
+}
+
+// TODO: description missing
+size_t control_index(size_t const g, size_t const* qubits, size_t const nqubits) {
+ size_t i = g;
+ for (size_t j = 0; j < nqubits; j++) {
+ size_t const n = qubits[j];
+ size_t const k = 1 << n;
+ i = ((i >> n) << (n + 1)) + (i & (k - 1)) + k;
+ }
+ return i;
+}
+
+// TODO: description missing
+void apply_controlled_gate(
+ complex double* state,
+ complex double const* gate,
+ size_t const* qubits,
+ size_t const ncontrols,
+ size_t const nqubits
+ ) {
+ size_t target = qubits[0];
+
+ size_t sorted_qubits[ncontrols + 1];
+ memcpy(sorted_qubits, qubits, (ncontrols + 1) * sizeof(size_t));
+ for (size_t i = 0; i < ncontrols + 1; i++) {
+ sorted_qubits[i] = nqubits - sorted_qubits[i] - 1;
+ }
+ qsort(sorted_qubits, ncontrols + 1, sizeof(size_t), compare);
+
+ size_t const nstates = 1 << (nqubits - ncontrols - 1);
+ size_t const tk = 1 << (nqubits - target - 1);
+ // TODO: This can be parallelized for large number of qubits
+ for (size_t g = 0; g < nstates; g++) {
+ size_t const i2 = control_index(g, sorted_qubits, ncontrols + 1);
+ size_t const i1 = i2 - tk;
+ complex double const state1 = state[i1];
+ complex double const state2 = state[i2];
+ state[i1] = gate[0] * state1 + gate[1] * state2;
+ state[i2] = gate[2] * state1 + gate[3] * state2;
+ }
+}
+
+// calculate number of control qubits
+// maybe can be improved if we expose gate n_elements to C API
+// but this will change anyway when we implement ``controlled_by``
+size_t n_controls(const char* gate) {
+ if (strcmp(gate, "CNOT") == 0) {
+ return 1;
+ }
+ return 0;
+}
+
+// execute a qibo-core circuit, mutating the state in place
+void execute_circuit(qibo_core_circuit* circuit, complex double* state) {
+ size_t const n_elements = qibo_core_circuit_n_elements(circuit);
+ size_t const n_gates = qibo_core_circuit_n_gates(circuit);
+
+ for (size_t gid = 0; gid < n_gates; gid++) {
+ char const* gate = qibo_core_circuit_gate(circuit, gid);
+
+ size_t const* elements;
+ size_t n_gate_elements;
+ qibo_core_circuit_elements(circuit, gid, &elements, &n_gate_elements);
+
+ complex double const* matrix_ = matrix(gate);
+ size_t n_controls_ = n_controls(gate);
+ apply_controlled_gate(state, matrix_, elements, n_controls_, n_elements);
+
+ qibo_core_circuit_free_elements(elements, n_gate_elements);
+ }
+}

crates/c/examples/microsimulator/microsim.h

@@ -0,0 +1,8 @@
+#ifndef MICROSIM_H
+#define MICROSIM_H
+
+#include "qibo_core_c.h"
+
+void execute_circuit(qibo_core_circuit *circuit, complex double *state);
+
+#endif

crates/c/src/lib.rs

@@ -5,6 +5,7 @@ use std::slice;
 
 use qibo_core::prelude::*;
 
+
 #[no_mangle]
 pub extern "C" fn qibo_core_circuit_new(n_elements: usize) -> Box<Circuit> {
  Box::new(Circuit::new(n_elements))
@@ -36,6 +37,47 @@ pub extern "C" fn qibo_core_circuit_n_elements(circuit: &Circuit) -> usize {
  circuit.n_elements()
 }
 
+#[no_mangle]
+pub extern "C" fn qibo_core_circuit_n_gates(circuit: &Circuit) -> usize {
+ circuit.n_gates()
+}
+
+#[no_mangle]
+pub extern "C" fn qibo_core_circuit_gate(circuit: &Circuit, gid: usize) -> *const c_char {
+ let gate = circuit.gate(gid);
+ let name = match gate {
+ Gate::One(One::H) => "H",
+ Gate::One(One::X) => "X",
+ Gate::One(One::Y) => "Y",
+ Gate::One(One::Z) => "Z",
+ Gate::Two(Two::CNOT) => "CNOT",
+ _ => todo!()
+ };
+
+ CString::new(name).unwrap().into_raw()
+}
+
+#[no_mangle]
+pub extern "C" fn qibo_core_circuit_elements(circuit: &Circuit, gid: usize, ptr: *mut *const usize, len: *mut usize) {
+ let elements = circuit.elements(gid);
+ // Complaints about what follows are to be directed to ChatGPT
+ let boxed_slice = elements.clone().into_boxed_slice();
+ unsafe {
+ *ptr = boxed_slice.as_ptr();
+ *len = elements.len();
+ }
+ std::mem::forget(boxed_slice);
+}
+
+#[no_mangle]
+pub extern "C" fn qibo_core_circuit_free_elements(ptr: *const usize, len: usize) {
+ if !ptr.is_null() {
+ unsafe {
+ let _ = Vec::from_raw_parts(ptr as *mut usize, len, len);
+ }
+ }
+}
+
 #[no_mangle]
 pub extern "C" fn qibo_core_circuit_draw(circuit: &Circuit) -> *mut c_char {
  let repr = circuit.draw();