feat: simd + testing + formatting

7 files changed, 128 insertions, 104 deletions

diff --git a/include/core/circuit.h b/include/core/circuit.h
index bbc864c..7c0d371 100644
--- a/include/core/circuit.h
+++ b/include/core/circuit.h
@@ -46,14 +46,14 @@ struct PsiGateOp
 	double params[3];
 	size_t param_count;
 	size_t classical;
-	struct PsiCustomGate *custom;
-	size_t *custom_targets;
+	struct PsiCustomGate* custom;
+	size_t* custom_targets;
 	size_t custom_target_count;
 };
 
-const char *psi_gate_op_name(struct PsiGateOp op);
-const size_t *psi_gate_op_quantum_targets(const struct PsiGateOp *op, size_t *out_count);
-const size_t *psi_gate_op_classical_targets(const struct PsiGateOp *op, size_t *out_count);
+const char* psi_gate_op_name(struct PsiGateOp op);
+const size_t* psi_gate_op_quantum_targets(const struct PsiGateOp* op, size_t* out_count);
+const size_t* psi_gate_op_classical_targets(const struct PsiGateOp* op, size_t* out_count);
 bool psi_gate_op_is_measurement(struct PsiGateOp op);
 bool psi_gate_op_is_custom(struct PsiGateOp op);
 bool psi_gate_op_is_non_clifford(struct PsiGateOp op);
@@ -62,7 +62,7 @@ struct PsiQuantumCircuit
 {
 	size_t num_qubits;
 	size_t num_classical;
-	struct PsiGateOp *operations;
+	struct PsiGateOp* operations;
 	size_t operation_count;
 	size_t operation_capacity;
 	struct PsiVector computed_state;
@@ -70,41 +70,44 @@ struct PsiQuantumCircuit
 };
 
 struct PsiQuantumCircuit psi_new_quantum_circuit(size_t num_qubits);
-struct PsiQuantumCircuit psi_new_quantum_circuit_with_classical(size_t num_qubits, size_t num_classical);
-void psi_free_quantum_circuit(struct PsiQuantumCircuit *c);
-void psi_reset_circuit(struct PsiQuantumCircuit *c);
+struct PsiQuantumCircuit psi_new_quantum_circuit_with_classical(size_t num_qubits,
+                                                                size_t num_classical);
+void psi_free_quantum_circuit(struct PsiQuantumCircuit* c);
+void psi_reset_circuit(struct PsiQuantumCircuit* c);
 
-void psi_apply_h(struct PsiQuantumCircuit *c, size_t target);
-void psi_apply_x(struct PsiQuantumCircuit *c, size_t target);
-void psi_apply_y(struct PsiQuantumCircuit *c, size_t target);
-void psi_apply_z(struct PsiQuantumCircuit *c, size_t target);
-void psi_apply_s(struct PsiQuantumCircuit *c, size_t target);
-void psi_apply_t(struct PsiQuantumCircuit *c, size_t target);
-void psi_apply_sdg(struct PsiQuantumCircuit *c, size_t target);
-void psi_apply_tdg(struct PsiQuantumCircuit *c, size_t target);
-void psi_apply_sx(struct PsiQuantumCircuit *c, size_t target);
-void psi_apply_sxdg(struct PsiQuantumCircuit *c, size_t target);
+void psi_apply_h(struct PsiQuantumCircuit* c, size_t target);
+void psi_apply_x(struct PsiQuantumCircuit* c, size_t target);
+void psi_apply_y(struct PsiQuantumCircuit* c, size_t target);
+void psi_apply_z(struct PsiQuantumCircuit* c, size_t target);
+void psi_apply_s(struct PsiQuantumCircuit* c, size_t target);
+void psi_apply_t(struct PsiQuantumCircuit* c, size_t target);
+void psi_apply_sdg(struct PsiQuantumCircuit* c, size_t target);
+void psi_apply_tdg(struct PsiQuantumCircuit* c, size_t target);
+void psi_apply_sx(struct PsiQuantumCircuit* c, size_t target);
+void psi_apply_sxdg(struct PsiQuantumCircuit* c, size_t target);
 
-void psi_apply_rx(struct PsiQuantumCircuit *c, size_t target, double theta);
-void psi_apply_ry(struct PsiQuantumCircuit *c, size_t target, double theta);
-void psi_apply_rz(struct PsiQuantumCircuit *c, size_t target, double theta);
-void psi_apply_p(struct PsiQuantumCircuit *c, size_t target, double theta);
-void psi_apply_u1(struct PsiQuantumCircuit *c, size_t target, double lambda);
-void psi_apply_u2(struct PsiQuantumCircuit *c, size_t target, double phi, double lambda);
-void psi_apply_u3(struct PsiQuantumCircuit *c, size_t target, double theta, double phi, double lambda);
+void psi_apply_rx(struct PsiQuantumCircuit* c, size_t target, double theta);
+void psi_apply_ry(struct PsiQuantumCircuit* c, size_t target, double theta);
+void psi_apply_rz(struct PsiQuantumCircuit* c, size_t target, double theta);
+void psi_apply_p(struct PsiQuantumCircuit* c, size_t target, double theta);
+void psi_apply_u1(struct PsiQuantumCircuit* c, size_t target, double lambda);
+void psi_apply_u2(struct PsiQuantumCircuit* c, size_t target, double phi, double lambda);
+void psi_apply_u3(struct PsiQuantumCircuit* c, size_t target, double theta, double phi,
+                  double lambda);
 
-void psi_apply_cnot(struct PsiQuantumCircuit *c, size_t control, size_t target);
-void psi_apply_cz(struct PsiQuantumCircuit *c, size_t control, size_t target);
-void psi_apply_swap(struct PsiQuantumCircuit *c, size_t qubit1, size_t qubit2);
-void psi_apply_crx(struct PsiQuantumCircuit *c, size_t control, size_t target, double theta);
-void psi_apply_cry(struct PsiQuantumCircuit *c, size_t control, size_t target, double theta);
-void psi_apply_crz(struct PsiQuantumCircuit *c, size_t control, size_t target, double theta);
-void psi_apply_cp(struct PsiQuantumCircuit *c, size_t control, size_t target, double theta);
+void psi_apply_cnot(struct PsiQuantumCircuit* c, size_t control, size_t target);
+void psi_apply_cz(struct PsiQuantumCircuit* c, size_t control, size_t target);
+void psi_apply_swap(struct PsiQuantumCircuit* c, size_t qubit1, size_t qubit2);
+void psi_apply_crx(struct PsiQuantumCircuit* c, size_t control, size_t target, double theta);
+void psi_apply_cry(struct PsiQuantumCircuit* c, size_t control, size_t target, double theta);
+void psi_apply_crz(struct PsiQuantumCircuit* c, size_t control, size_t target, double theta);
+void psi_apply_cp(struct PsiQuantumCircuit* c, size_t control, size_t target, double theta);
 
-void psi_apply_ccnot(struct PsiQuantumCircuit *c, size_t control1, size_t control2, size_t target);
-void psi_apply_cswap(struct PsiQuantumCircuit *c, size_t control, size_t target1, size_t target2);
+void psi_apply_ccnot(struct PsiQuantumCircuit* c, size_t control1, size_t control2, size_t target);
+void psi_apply_cswap(struct PsiQuantumCircuit* c, size_t control, size_t target1, size_t target2);
 
-void psi_measure(struct PsiQuantumCircuit *c, size_t qubit, size_t classical);
-void psi_measure_all(struct PsiQuantumCircuit *c);
+void psi_measure(struct PsiQuantumCircuit* c, size_t qubit, size_t classical);
+void psi_measure_all(struct PsiQuantumCircuit* c);
 
-void psi_apply_custom(struct PsiQuantumCircuit *c, struct PsiCustomGate gate, const size_t *targets, size_t count);
+void psi_apply_custom(struct PsiQuantumCircuit* c, struct PsiCustomGate gate, const size_t* targets,
+                      size_t count);
diff --git a/include/core/classical_components.h b/include/core/classical_components.h
index 48714b4..53c00ef 100644
--- a/include/core/classical_components.h
+++ b/include/core/classical_components.h
@@ -5,17 +5,18 @@
 
 struct PsiClassicalBit
 {
-	const char *name;
+	const char* name;
 	bool state;
 };
 
 struct PsiClassicalRegister
 {
-	const char *name;
-	struct PsiClassicalBit *bits;
+	const char* name;
+	struct PsiClassicalBit* bits;
 	size_t num_bits;
 };
 
-struct PsiClassicalBit psi_new_classical_bit(const char *name, bool state);
-struct PsiClassicalRegister psi_new_classical_register(const char *name, const char **names, size_t count);
-void psi_free_classical_register(struct PsiClassicalRegister *reg);
+struct PsiClassicalBit psi_new_classical_bit(const char* name, bool state);
+struct PsiClassicalRegister psi_new_classical_register(const char* name, const char** names,
+                                                       size_t count);
+void psi_free_classical_register(struct PsiClassicalRegister* reg);
diff --git a/include/core/custom_gate.h b/include/core/custom_gate.h
index bc22956..efda36f 100644
--- a/include/core/custom_gate.h
+++ b/include/core/custom_gate.h
@@ -35,7 +35,7 @@ enum PsiCustomGateKind
 
 struct PsiCustomGate
 {
-	const char *name;
+	const char* name;
 	size_t num_qubits;
 	enum PsiCustomGateKind kind;
 	union
@@ -43,14 +43,16 @@ struct PsiCustomGate
 		struct PsiMatrix matrix;
 		struct
 		{
-			struct PsiCompositeGateOp *ops;
+			struct PsiCompositeGateOp* ops;
 			size_t count;
 		} composite;
 	} definition;
 };
 
-struct PsiCustomGate psi_new_custom_gate_from_matrix(const char *name, struct PsiMatrix matrix);
-struct PsiCustomGate psi_new_custom_gate_from_composite(const char *name, size_t num_qubits, const struct PsiCompositeGateOp *ops, size_t op_count);
-void psi_free_custom_gate(struct PsiCustomGate *gate);
+struct PsiCustomGate psi_new_custom_gate_from_matrix(const char* name, struct PsiMatrix matrix);
+struct PsiCustomGate psi_new_custom_gate_from_composite(const char* name, size_t num_qubits,
+                                                        const struct PsiCompositeGateOp* ops,
+                                                        size_t op_count);
+void psi_free_custom_gate(struct PsiCustomGate* gate);
 
 struct PsiQuantumGate psi_to_quantum_gate(struct PsiCustomGate gate);
diff --git a/include/core/kernel.h b/include/core/kernel.h
index d7976c3..b8b19ea 100644
--- a/include/core/kernel.h
+++ b/include/core/kernel.h
@@ -16,39 +16,40 @@ enum PsiGateType
 struct PsiKernel
 {
 	struct PsiMatrix matrix;
-	size_t *targets;
+	size_t* targets;
 	size_t target_count;
-	char *name;
+	char* name;
 	enum PsiGateType gate_type;
 };
 
-struct PsiKernel psi_new_kernel(const char *name, struct PsiMatrix matrix, const size_t *targets, size_t target_count);
+struct PsiKernel psi_new_kernel(const char* name, struct PsiMatrix matrix, const size_t* targets,
+                                size_t target_count);
 struct PsiKernel psi_clone_kernel(struct PsiKernel kernel);
-void psi_free_kernel(struct PsiKernel *kernel);
+void psi_free_kernel(struct PsiKernel* kernel);
 
 bool psi_kernels_share_qubits(struct PsiKernel a, struct PsiKernel b);
 bool psi_kernels_commute(struct PsiKernel a, struct PsiKernel b);
 bool psi_kernels_can_fuse(struct PsiKernel a, struct PsiKernel b);
-bool psi_fuse_kernels(struct PsiKernel a, struct PsiKernel b, struct PsiKernel *out);
+bool psi_fuse_kernels(struct PsiKernel a, struct PsiKernel b, struct PsiKernel* out);
 
 struct PsiKernelBatch
 {
-	struct PsiKernel *kernels;
+	struct PsiKernel* kernels;
 	size_t count;
 	size_t capacity;
 	size_t num_qubits;
 };
 
 struct PsiKernelBatch psi_new_kernel_batch(size_t num_qubits);
-void psi_free_kernel_batch(struct PsiKernelBatch *batch);
-void psi_add_kernel(struct PsiKernelBatch *batch, struct PsiKernel kernel);
-void psi_optimize_kernel_batch(struct PsiKernelBatch *batch);
-void psi_execute_kernel_batch(struct PsiKernelBatch batch, struct PsiVector *state);
-void psi_apply_kernel(struct PsiVector *state, struct PsiKernel kernel, size_t num_qubits);
+void psi_free_kernel_batch(struct PsiKernelBatch* batch);
+void psi_add_kernel(struct PsiKernelBatch* batch, struct PsiKernel kernel);
+void psi_optimize_kernel_batch(struct PsiKernelBatch* batch);
+void psi_execute_kernel_batch(struct PsiKernelBatch batch, struct PsiVector* state);
+void psi_apply_kernel(struct PsiVector* state, struct PsiKernel kernel, size_t num_qubits);
 
 struct PsiExecutionLayer
 {
-	struct PsiKernel *kernels;
+	struct PsiKernel* kernels;
 	size_t count;
 	size_t capacity;
 };
@@ -65,10 +66,10 @@ struct PsiKernelStats
 
 struct PsiStructureAwareBatch
 {
-	struct PsiKernel *kernels;
+	struct PsiKernel* kernels;
 	size_t count;
 	size_t capacity;
-	struct PsiExecutionLayer *layers;
+	struct PsiExecutionLayer* layers;
 	size_t layer_count;
 	size_t layer_capacity;
 	size_t num_qubits;
@@ -76,9 +77,11 @@ struct PsiStructureAwareBatch
 };
 
 struct PsiStructureAwareBatch psi_new_structure_aware_batch(size_t num_qubits);
-void psi_free_structure_aware_batch(struct PsiStructureAwareBatch *batch);
-void psi_add_structure_aware_kernel(struct PsiStructureAwareBatch *batch, struct PsiKernel kernel);
-void psi_optimize_structure_aware_batch(struct PsiStructureAwareBatch *batch);
-void psi_execute_structure_aware_batch(struct PsiStructureAwareBatch batch, struct PsiVector *state);
-void psi_execute_structure_aware_batch_layered(struct PsiStructureAwareBatch batch, struct PsiVector *state);
+void psi_free_structure_aware_batch(struct PsiStructureAwareBatch* batch);
+void psi_add_structure_aware_kernel(struct PsiStructureAwareBatch* batch, struct PsiKernel kernel);
+void psi_optimize_structure_aware_batch(struct PsiStructureAwareBatch* batch);
+void psi_execute_structure_aware_batch(struct PsiStructureAwareBatch batch,
+                                       struct PsiVector* state);
+void psi_execute_structure_aware_batch_layered(struct PsiStructureAwareBatch batch,
+                                               struct PsiVector* state);
 struct PsiKernelStats psi_structure_aware_batch_stats(struct PsiStructureAwareBatch batch);
diff --git a/include/core/noise.h b/include/core/noise.h
index 6232d8e..320a4ab 100644
--- a/include/core/noise.h
+++ b/include/core/noise.h
@@ -9,22 +9,24 @@
 struct PsiKrausOperator
 {
 	struct PsiMatrix matrix;
-	const char *name;
+	const char* name;
 };
 
-struct PsiKrausOperator psi_new_kraus_operator(const char *name, struct PsiMatrix matrix);
-void psi_free_kraus_operator(struct PsiKrausOperator *op);
+struct PsiKrausOperator psi_new_kraus_operator(const char* name, struct PsiMatrix matrix);
+void psi_free_kraus_operator(struct PsiKrausOperator* op);
 
 struct PsiNoiseChannel
 {
-	const char *name;
-	struct PsiKrausOperator *operators;
+	const char* name;
+	struct PsiKrausOperator* operators;
 	size_t operator_count;
 	size_t num_qubits;
 };
 
-struct PsiNoiseChannel psi_new_noise_channel(const char *name, const struct PsiKrausOperator *operators, size_t count, size_t num_qubits);
-void psi_free_noise_channel(struct PsiNoiseChannel *channel);
+struct PsiNoiseChannel psi_new_noise_channel(const char* name,
+                                             const struct PsiKrausOperator* operators, size_t count,
+                                             size_t num_qubits);
+void psi_free_noise_channel(struct PsiNoiseChannel* channel);
 
 struct PsiNoiseChannel psi_depolarising_channel(double p);
 struct PsiNoiseChannel psi_amplitude_damping_channel(double gamma);
@@ -36,22 +38,27 @@ struct PsiNoiseChannel psi_generalised_amplitude_damping_channel(double p, doubl
 
 struct PsiDensityMatrix
 {
-	struct PsiComplex *data;
+	struct PsiComplex* data;
 	size_t dim;
 	size_t num_qubits;
 };
 
 struct PsiDensityMatrix psi_new_density_matrix(size_t num_qubits);
-struct PsiDensityMatrix psi_new_density_matrix_from_state(const struct PsiComplex *state, size_t len);
-void psi_free_density_matrix(struct PsiDensityMatrix *dm);
+struct PsiDensityMatrix psi_new_density_matrix_from_state(const struct PsiComplex* state,
+                                                          size_t len);
+void psi_free_density_matrix(struct PsiDensityMatrix* dm);
 
 struct PsiComplex psi_get_density_matrix(struct PsiDensityMatrix dm, size_t row, size_t col);
-void psi_set_density_matrix(struct PsiDensityMatrix *dm, size_t row, size_t col, struct PsiComplex value);
+void psi_set_density_matrix(struct PsiDensityMatrix* dm, size_t row, size_t col,
+                            struct PsiComplex value);
 struct PsiComplex psi_trace_density_matrix(struct PsiDensityMatrix dm);
 double psi_purity_density_matrix(struct PsiDensityMatrix dm);
 bool psi_is_pure_density_matrix(struct PsiDensityMatrix dm, double tolerance);
-void psi_density_matrix_probabilities(struct PsiDensityMatrix dm, double *out);
-void psi_apply_unitary_density_matrix(struct PsiDensityMatrix *dm, struct PsiMatrix gate, const size_t *targets, size_t target_count);
-void psi_apply_noise_channel(struct PsiDensityMatrix *dm, struct PsiNoiseChannel channel, size_t target);
-double psi_measure_probability_density_matrix(struct PsiDensityMatrix dm, size_t qubit, size_t outcome);
-double psi_fidelity_density_matrix(struct PsiDensityMatrix dm, const struct PsiComplex *state);
+void psi_density_matrix_probabilities(struct PsiDensityMatrix dm, double* out);
+void psi_apply_unitary_density_matrix(struct PsiDensityMatrix* dm, struct PsiMatrix gate,
+                                      const size_t* targets, size_t target_count);
+void psi_apply_noise_channel(struct PsiDensityMatrix* dm, struct PsiNoiseChannel channel,
+                             size_t target);
+double psi_measure_probability_density_matrix(struct PsiDensityMatrix dm, size_t qubit,
+                                              size_t outcome);
+double psi_fidelity_density_matrix(struct PsiDensityMatrix dm, const struct PsiComplex* state);
diff --git a/include/core/quantum_components.h b/include/core/quantum_components.h
index b238b5a..63797cf 100644
--- a/include/core/quantum_components.h
+++ b/include/core/quantum_components.h
@@ -10,34 +10,38 @@ struct PsiVector psi_new_state_1(void);
 
 struct PsiQuantumGate
 {
-	const char *name;
+	const char* name;
 	struct PsiMatrix matrix;
 	size_t num_qubits;
 };
 
-struct PsiQuantumGate psi_new_quantum_gate(const char *name, struct PsiMatrix matrix, size_t num_qubits);
-struct PsiQuantumGate psi_new_quantum_gate_from_matrix(const char *name, struct PsiMatrix matrix);
-void psi_free_quantum_gate(struct PsiQuantumGate *gate);
+struct PsiQuantumGate psi_new_quantum_gate(const char* name, struct PsiMatrix matrix,
+                                           size_t num_qubits);
+struct PsiQuantumGate psi_new_quantum_gate_from_matrix(const char* name, struct PsiMatrix matrix);
+void psi_free_quantum_gate(struct PsiQuantumGate* gate);
 
 struct PsiQuantumBit
 {
-	const char *name;
+	const char* name;
 	struct PsiVector state;
 };
 
-struct PsiQuantumBit psi_new_quantum_bit(const char *name, struct PsiVector state);
-void psi_free_quantum_bit(struct PsiQuantumBit *bit);
+struct PsiQuantumBit psi_new_quantum_bit(const char* name, struct PsiVector state);
+void psi_free_quantum_bit(struct PsiQuantumBit* bit);
 
 struct PsiQuantumRegister
 {
-	const char *name;
+	const char* name;
 	struct PsiVector state_vector;
-	struct PsiQuantumBit *qubits;
+	struct PsiQuantumBit* qubits;
 	size_t num_qubits;
 };
 
-struct PsiQuantumRegister psi_new_quantum_register(const char *name, const char **names, size_t count);
-struct PsiQuantumRegister psi_new_quantum_register_from(const char *name, const struct PsiQuantumBit *bits, size_t count);
-void psi_free_quantum_register(struct PsiQuantumRegister *reg);
+struct PsiQuantumRegister psi_new_quantum_register(const char* name, const char** names,
+                                                   size_t count);
+struct PsiQuantumRegister
+psi_new_quantum_register_from(const char* name, const struct PsiQuantumBit* bits, size_t count);
+void psi_free_quantum_register(struct PsiQuantumRegister* reg);
 
-void psi_apply_gate(struct PsiQuantumRegister *reg, struct PsiQuantumGate gate, const size_t *targets, size_t target_count);
+void psi_apply_gate(struct PsiQuantumRegister* reg, struct PsiQuantumGate gate,
+                    const size_t* targets, size_t target_count);
diff --git a/include/core/runtime.h b/include/core/runtime.h
index 9e7427e..2a6f739 100644
--- a/include/core/runtime.h
+++ b/include/core/runtime.h
@@ -33,11 +33,15 @@ struct PsiRuntimeConfig psi_new_runtime_config(void);
 struct PsiRuntimeConfig psi_optimal_runtime_config(void);
 struct PsiRuntimeConfig psi_runtime_to_config(enum PsiRuntime runtime);
 
-struct PsiVector psi_compute_runtime_config(struct PsiRuntimeConfig config, size_t num_qubits, const struct PsiGateOp *operations, size_t op_count);
-struct PsiVector psi_compute_runtime(enum PsiRuntime runtime, size_t num_qubits, const struct PsiGateOp *operations, size_t op_count);
+struct PsiVector psi_compute_runtime_config(struct PsiRuntimeConfig config, size_t num_qubits,
+                                            const struct PsiGateOp* operations, size_t op_count);
+struct PsiVector psi_compute_runtime(enum PsiRuntime runtime, size_t num_qubits,
+                                     const struct PsiGateOp* operations, size_t op_count);
 
-const struct PsiVector *psi_compute_circuit(struct PsiQuantumCircuit *circuit);
-const struct PsiVector *psi_compute_circuit_with(struct PsiQuantumCircuit *circuit, enum PsiRuntime runtime);
-const struct PsiVector *psi_compute_circuit_with_config(struct PsiQuantumCircuit *circuit, struct PsiRuntimeConfig config);
-double psi_circuit_probability(struct PsiQuantumCircuit *circuit, size_t state_index);
-void psi_circuit_probabilities(struct PsiQuantumCircuit *circuit, double *out);
+const struct PsiVector* psi_compute_circuit(struct PsiQuantumCircuit* circuit);
+const struct PsiVector* psi_compute_circuit_with(struct PsiQuantumCircuit* circuit,
+                                                 enum PsiRuntime runtime);
+const struct PsiVector* psi_compute_circuit_with_config(struct PsiQuantumCircuit* circuit,
+                                                        struct PsiRuntimeConfig config);
+double psi_circuit_probability(struct PsiQuantumCircuit* circuit, size_t state_index);
+void psi_circuit_probabilities(struct PsiQuantumCircuit* circuit, double* out);