feat: add matrix, vector, and circuit display + fmt

1 files changed, 68 insertions, 68 deletions

diff --git a/src/maths/vector.c b/src/maths/vector.c
index 1c5c4f9..5cd49e0 100644
--- a/src/maths/vector.c
+++ b/src/maths/vector.c
@@ -6,155 +6,155 @@
 
 static enum PsiVectorKind flip_kind(enum PsiVectorKind kind)
 {
-	if (kind == PSI_ROW_VECTOR)
-		return PSI_COLUMN_VECTOR;
+    if (kind == PSI_ROW_VECTOR)
+        return PSI_COLUMN_VECTOR;
 
-	return PSI_ROW_VECTOR;
+    return PSI_ROW_VECTOR;
 }
 
 struct PsiVector psi_new_vector(size_t size, enum PsiVectorKind kind)
 {
-	struct PsiComplex* data = calloc(size, sizeof(struct PsiComplex));
-	assert(data != NULL || size == 0);
+    struct PsiComplex* data = calloc(size, sizeof(struct PsiComplex));
+    assert(data != NULL || size == 0);
 
-	return (struct PsiVector){
-		data,
-		size,
-		kind,
-	};
+    return (struct PsiVector){
+        data,
+        size,
+        kind,
+    };
 }
 
 struct PsiVector psi_new_vector_from(const struct PsiComplex* data, size_t size,
                                      enum PsiVectorKind kind)
 {
-	struct PsiVector v = psi_new_vector(size, kind);
-	memcpy(v.data, data, size * sizeof(struct PsiComplex));
+    struct PsiVector v = psi_new_vector(size, kind);
+    memcpy(v.data, data, size * sizeof(struct PsiComplex));
 
-	return v;
+    return v;
 }
 
 struct PsiVector psi_clone_vector(struct PsiVector v)
 {
-	return psi_new_vector_from(v.data, v.size, v.kind);
+    return psi_new_vector_from(v.data, v.size, v.kind);
 }
 
 void psi_free_vector(struct PsiVector* v)
 {
-	free(v->data);
-	v->data = NULL;
-	v->size = 0;
+    free(v->data);
+    v->data = NULL;
+    v->size = 0;
 }
 
 struct PsiComplex psi_get_vector(struct PsiVector v, size_t index)
 {
-	assert(index < v.size);
-	return v.data[index];
+    assert(index < v.size);
+    return v.data[index];
 }
 
 void psi_set_vector(struct PsiVector* v, size_t index, struct PsiComplex value)
 {
-	assert(index < v->size);
-	v->data[index] = value;
+    assert(index < v->size);
+    v->data[index] = value;
 }
 
 struct PsiComplex psi_dot_vector(struct PsiVector a, struct PsiVector b)
 {
-	assert(a.size == b.size);
+    assert(a.size == b.size);
 
-	struct PsiComplex sum = psi_new_complex(0.0, 0.0);
-	for (size_t i = 0; i < a.size; i++)
-		sum = psi_add_complex(sum, psi_mul_complex(a.data[i], b.data[i]));
+    struct PsiComplex sum = psi_new_complex(0.0, 0.0);
+    for (size_t i = 0; i < a.size; i++)
+        sum = psi_add_complex(sum, psi_mul_complex(a.data[i], b.data[i]));
 
-	return sum;
+    return sum;
 }
 
 struct PsiComplex psi_norm_vector(struct PsiVector v)
 {
-	struct PsiComplex sum = psi_new_complex(0.0, 0.0);
-	for (size_t i = 0; i < v.size; i++)
-		sum = psi_add_complex(sum, psi_mul_complex(v.data[i], v.data[i]));
+    struct PsiComplex sum = psi_new_complex(0.0, 0.0);
+    for (size_t i = 0; i < v.size; i++)
+        sum = psi_add_complex(sum, psi_mul_complex(v.data[i], v.data[i]));
 
-	return psi_sqrt_complex(sum);
+    return psi_sqrt_complex(sum);
 }
 
 struct PsiComplex psi_sum_vector(struct PsiVector v)
 {
-	struct PsiComplex sum = psi_new_complex(0.0, 0.0);
-	for (size_t i = 0; i < v.size; i++)
-		sum = psi_add_complex(sum, v.data[i]);
+    struct PsiComplex sum = psi_new_complex(0.0, 0.0);
+    for (size_t i = 0; i < v.size; i++)
+        sum = psi_add_complex(sum, v.data[i]);
 
-	return sum;
+    return sum;
 }
 
 static int less_than(struct PsiComplex a, struct PsiComplex b)
 {
-	if (a.real != b.real)
-		return a.real < b.real;
+    if (a.real != b.real)
+        return a.real < b.real;
 
-	return a.imaginary < b.imaginary;
+    return a.imaginary < b.imaginary;
 }
 
 struct PsiComplex psi_max_vector(struct PsiVector v)
 {
-	if (v.size == 0)
-		return psi_new_complex(0.0, 0.0);
+    if (v.size == 0)
+        return psi_new_complex(0.0, 0.0);
 
-	struct PsiComplex best = v.data[0];
-	for (size_t i = 1; i < v.size; i++)
-		if (less_than(best, v.data[i]))
-			best = v.data[i];
+    struct PsiComplex best = v.data[0];
+    for (size_t i = 1; i < v.size; i++)
+        if (less_than(best, v.data[i]))
+            best = v.data[i];
 
-	return best;
+    return best;
 }
 
 struct PsiComplex psi_min_vector(struct PsiVector v)
 {
-	if (v.size == 0)
-		return psi_new_complex(0.0, 0.0);
+    if (v.size == 0)
+        return psi_new_complex(0.0, 0.0);
 
-	struct PsiComplex best = v.data[0];
-	for (size_t i = 1; i < v.size; i++)
-		if (less_than(v.data[i], best))
-			best = v.data[i];
+    struct PsiComplex best = v.data[0];
+    for (size_t i = 1; i < v.size; i++)
+        if (less_than(v.data[i], best))
+            best = v.data[i];
 
-	return best;
+    return best;
 }
 
 struct PsiVector psi_add_vector(struct PsiVector a, struct PsiVector b)
 {
-	assert(a.size == b.size);
+    assert(a.size == b.size);
 
-	struct PsiVector result = psi_new_vector(a.size, a.kind);
-	for (size_t i = 0; i < a.size; i++)
-		result.data[i] = psi_add_complex(a.data[i], b.data[i]);
+    struct PsiVector result = psi_new_vector(a.size, a.kind);
+    for (size_t i = 0; i < a.size; i++)
+        result.data[i] = psi_add_complex(a.data[i], b.data[i]);
 
-	return result;
+    return result;
 }
 
 struct PsiVector psi_sub_vector(struct PsiVector a, struct PsiVector b)
 {
-	assert(a.size == b.size);
+    assert(a.size == b.size);
 
-	struct PsiVector result = psi_new_vector(a.size, a.kind);
-	for (size_t i = 0; i < a.size; i++)
-		result.data[i] = psi_sub_complex(a.data[i], b.data[i]);
+    struct PsiVector result = psi_new_vector(a.size, a.kind);
+    for (size_t i = 0; i < a.size; i++)
+        result.data[i] = psi_sub_complex(a.data[i], b.data[i]);
 
-	return result;
+    return result;
 }
 
 struct PsiVector psi_scale_vector(struct PsiVector v, struct PsiComplex scalar)
 {
-	struct PsiVector result = psi_new_vector(v.size, v.kind);
-	for (size_t i = 0; i < v.size; i++)
-		result.data[i] = psi_mul_complex(v.data[i], scalar);
+    struct PsiVector result = psi_new_vector(v.size, v.kind);
+    for (size_t i = 0; i < v.size; i++)
+        result.data[i] = psi_mul_complex(v.data[i], scalar);
 
-	return result;
+    return result;
 }
 
 struct PsiVector psi_transpose_vector(struct PsiVector v)
 {
-	struct PsiVector result = psi_clone_vector(v);
-	result.kind = flip_kind(v.kind);
+    struct PsiVector result = psi_clone_vector(v);
+    result.kind = flip_kind(v.kind);
 
-	return result;
+    return result;
 }