feat: simd + testing + formatting

1 files changed, 31 insertions, 29 deletions

diff --git a/src/core/quantum_components.c b/src/core/quantum_components.c
index 31d60dc..a62a911 100644
--- a/src/core/quantum_components.c
+++ b/src/core/quantum_components.c
@@ -14,21 +14,21 @@ struct PsiVector psi_new_state_1(void)
 	return psi_column_vector(psi_new_complex(0.0, 0.0), psi_new_complex(1.0, 0.0));
 }
 
-struct PsiQuantumGate psi_new_quantum_gate(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)
 {
 	size_t expected_dim = (size_t)1 << num_qubits;
 	assert(matrix.rows == expected_dim);
 	assert(matrix.cols == expected_dim);
 
-	return (struct PsiQuantumGate)
-	{
+	return (struct PsiQuantumGate){
 		name,
 		matrix,
 		num_qubits,
 	};
 }
 
-struct PsiQuantumGate psi_new_quantum_gate_from_matrix(const char *name, struct PsiMatrix matrix)
+struct PsiQuantumGate psi_new_quantum_gate_from_matrix(const char* name, struct PsiMatrix matrix)
 {
 	assert(matrix.rows == matrix.cols);
 
@@ -39,34 +39,32 @@ struct PsiQuantumGate psi_new_quantum_gate_from_matrix(const char *name, struct
 	while (((size_t)1 << num_qubits) < dim)
 		num_qubits++;
 
-	return (struct PsiQuantumGate)
-	{
+	return (struct PsiQuantumGate){
 		name,
 		matrix,
 		num_qubits,
 	};
 }
 
-void psi_free_quantum_gate(struct PsiQuantumGate *gate)
+void psi_free_quantum_gate(struct PsiQuantumGate* gate)
 {
 	psi_free_matrix(&gate->matrix);
 }
 
-struct PsiQuantumBit psi_new_quantum_bit(const char *name, struct PsiVector state)
+struct PsiQuantumBit psi_new_quantum_bit(const char* name, struct PsiVector state)
 {
-	return (struct PsiQuantumBit)
-	{
+	return (struct PsiQuantumBit){
 		name,
 		state,
 	};
 }
 
-void psi_free_quantum_bit(struct PsiQuantumBit *bit)
+void psi_free_quantum_bit(struct PsiQuantumBit* bit)
 {
 	psi_free_vector(&bit->state);
 }
 
-static void update_register(struct PsiQuantumRegister *reg)
+static void update_register(struct PsiQuantumRegister* reg)
 {
 	psi_free_vector(&reg->state_vector);
 
@@ -90,16 +88,16 @@ static void update_register(struct PsiQuantumRegister *reg)
 	psi_free_matrix(&result);
 }
 
-struct PsiQuantumRegister psi_new_quantum_register(const char *name, const char **names, size_t count)
+struct PsiQuantumRegister psi_new_quantum_register(const char* name, const char** names,
+                                                   size_t count)
 {
-	struct PsiQuantumBit *qubits = malloc(count * sizeof(struct PsiQuantumBit));
+	struct PsiQuantumBit* qubits = malloc(count * sizeof(struct PsiQuantumBit));
 	assert(qubits != NULL || count == 0);
 
 	for (size_t i = 0; i < count; i++)
 		qubits[i] = psi_new_quantum_bit(names[i], psi_new_state_0());
 
-	struct PsiQuantumRegister reg =
-	{
+	struct PsiQuantumRegister reg = {
 		name,
 		psi_new_vector(0, PSI_COLUMN_VECTOR),
 		qubits,
@@ -110,16 +108,16 @@ struct PsiQuantumRegister psi_new_quantum_register(const char *name, const char
 	return reg;
 }
 
-struct PsiQuantumRegister psi_new_quantum_register_from(const char *name, const struct PsiQuantumBit *bits, size_t count)
+struct PsiQuantumRegister
+psi_new_quantum_register_from(const char* name, const struct PsiQuantumBit* bits, size_t count)
 {
-	struct PsiQuantumBit *qubits = malloc(count * sizeof(struct PsiQuantumBit));
+	struct PsiQuantumBit* qubits = malloc(count * sizeof(struct PsiQuantumBit));
 	assert(qubits != NULL || count == 0);
 
 	for (size_t i = 0; i < count; i++)
 		qubits[i] = psi_new_quantum_bit(bits[i].name, psi_clone_vector(bits[i].state));
 
-	struct PsiQuantumRegister reg =
-	{
+	struct PsiQuantumRegister reg = {
 		name,
 		psi_new_vector(0, PSI_COLUMN_VECTOR),
 		qubits,
@@ -130,7 +128,7 @@ struct PsiQuantumRegister psi_new_quantum_register_from(const char *name, const
 	return reg;
 }
 
-void psi_free_quantum_register(struct PsiQuantumRegister *reg)
+void psi_free_quantum_register(struct PsiQuantumRegister* reg)
 {
 	for (size_t i = 0; i < reg->num_qubits; i++)
 		psi_free_quantum_bit(&reg->qubits[i]);
@@ -141,7 +139,7 @@ void psi_free_quantum_register(struct PsiQuantumRegister *reg)
 	psi_free_vector(&reg->state_vector);
 }
 
-static bool targets_contain(const size_t *targets, size_t count, size_t value)
+static bool targets_contain(const size_t* targets, size_t count, size_t value)
 {
 	for (size_t i = 0; i < count; i++)
 		if (targets[i] == value)
@@ -150,7 +148,8 @@ static bool targets_contain(const size_t *targets, size_t count, size_t value)
 	return false;
 }
 
-static struct PsiMatrix build_contiguous_operator(struct PsiQuantumRegister reg, struct PsiQuantumGate gate, size_t start_idx)
+static struct PsiMatrix build_contiguous_operator(struct PsiQuantumRegister reg,
+                                                  struct PsiQuantumGate gate, size_t start_idx)
 {
 	size_t n = reg.num_qubits;
 	size_t g = gate.num_qubits;
@@ -163,9 +162,8 @@ static struct PsiMatrix build_contiguous_operator(struct PsiQuantumRegister reg,
 		if (i > start_idx && i < start_idx + g)
 			continue;
 
-		struct PsiMatrix part = i == start_idx
-			? psi_clone_matrix(gate.matrix)
-			: psi_identity_matrix(2);
+		struct PsiMatrix part =
+				i == start_idx ? psi_clone_matrix(gate.matrix) : psi_identity_matrix(2);
 
 		if (!has_result)
 		{
@@ -186,7 +184,9 @@ static struct PsiMatrix build_contiguous_operator(struct PsiQuantumRegister reg,
 	return result;
 }
 
-static struct PsiMatrix build_full_operator(struct PsiQuantumRegister reg, struct PsiQuantumGate gate, const size_t *targets, size_t target_count)
+static struct PsiMatrix build_full_operator(struct PsiQuantumRegister reg,
+                                            struct PsiQuantumGate gate, const size_t* targets,
+                                            size_t target_count)
 {
 	size_t n = reg.num_qubits;
 	size_t g = gate.num_qubits;
@@ -238,13 +238,15 @@ static struct PsiMatrix build_full_operator(struct PsiQuantumRegister reg, struc
 			}
 
 			if (non_target_match)
-				result.data[row * result.cols + col] = psi_get_matrix(gate.matrix, target_row_bits, target_col_bits);
+				result.data[row * result.cols + col] =
+						psi_get_matrix(gate.matrix, target_row_bits, target_col_bits);
 		}
 
 	return result;
 }
 
-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)
 {
 	size_t n = reg->num_qubits;