1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
#include "maths/vector.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
static enum PsiVectorKind flip_kind(enum PsiVectorKind kind)
{
if (kind == PSI_ROW_VECTOR)
return PSI_COLUMN_VECTOR;
return PSI_ROW_VECTOR;
}
struct PsiVector psi_new_vector(size_t size, enum PsiVectorKind kind)
{
// all-zero bits == 0.0 for both components
struct PsiComplex *data = calloc(size, sizeof(struct PsiComplex));
assert(data != NULL || size == 0);
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));
return v;
}
struct PsiVector psi_clone_vector(struct PsiVector v)
{
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;
}
struct PsiComplex psi_get_vector(struct PsiVector v, size_t 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;
}
struct PsiComplex psi_dot_vector(struct PsiVector a, struct PsiVector b)
{
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]));
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]));
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]);
return sum;
}
// ordering mirrors rust's derived PartialOrd: real first, then imaginary
static int less_than(struct PsiComplex a, struct PsiComplex b)
{
if (a.real != b.real)
return a.real < b.real;
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);
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;
}
struct PsiComplex psi_min_vector(struct PsiVector v)
{
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];
return best;
}
struct PsiVector psi_add_vector(struct PsiVector a, struct PsiVector b)
{
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]);
return result;
}
struct PsiVector psi_sub_vector(struct PsiVector a, struct PsiVector b)
{
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]);
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);
return result;
}
struct PsiVector psi_transpose_vector(struct PsiVector v)
{
struct PsiVector result = psi_clone_vector(v);
result.kind = flip_kind(v.kind);
return result;
}
|
