linear_algebra.cpp
impl/subjects/math/linear_algebra.cpp · 616 line(s) · c
#include "linear_algebra.h"
#include <algorithm>
#include <cmath>
#include <cstring>
#include <utility>
#include <cstdint>
#include <limits>
#include <new>
#include <vector>
namespace {
bool count_ok(size_t a, size_t b, size_t *out) {
if (!out || (b && a > std::numeric_limits<size_t>::max() / b))
return false;
*out = a * b;
return true;
}
bool valid_range(const double *p, size_t n) {
size_t bytes = 0;
return p && count_ok(n, sizeof(double), &bytes) &&
reinterpret_cast<uintptr_t>(p) <=
std::numeric_limits<uintptr_t>::max() - bytes;
}
bool valid_range(double *p, size_t n) {
return valid_range(static_cast<const double *>(p), n);
}
template <typename F>
slmath_status vector_binary(const double *a, const double *b,
double *out, size_t n, F fn) {
if (!valid_range(a, n) || !valid_range(b, n) || !valid_range(out, n))
return SLMATH_INVALID_ARGUMENT;
for (size_t i = 0; i < n; ++i) out[i] = fn(a[i], b[i]);
return SLMATH_OK;
}
} // namespace
extern "C" {
slmath_status slmath_vector_add(const double *a, const double *b,
double *out, size_t n) {
return vector_binary(a, b, out, n,
[](double x, double y) { return x + y; });
}
slmath_status slmath_vector_subtract(const double *a, const double *b,
double *out, size_t n) {
return vector_binary(a, b, out, n,
[](double x, double y) { return x - y; });
}
slmath_status slmath_vector_scale(const double *a, double scalar,
double *out, size_t n) {
if (!valid_range(a, n) || !valid_range(out, n))
return SLMATH_INVALID_ARGUMENT;
for (size_t i = 0; i < n; ++i) out[i] = a[i] * scalar;
return SLMATH_OK;
}
slmath_status slmath_vector_dot(const double *a, const double *b,
size_t n, double *out) {
if (!valid_range(a, n) || !valid_range(b, n) || !out)
return SLMATH_INVALID_ARGUMENT;
double sum = 0.0;
double correction = 0.0;
for (size_t i = 0; i < n; ++i) {
const double product = a[i] * b[i];
const double adjusted = product - correction;
const double next = sum + adjusted;
correction = (next - sum) - adjusted;
sum = next;
}
*out = sum;
return SLMATH_OK;
}
slmath_status slmath_vector_norm(const double *a, size_t n, double *out) {
if (!valid_range(a, n) || !out) return SLMATH_INVALID_ARGUMENT;
/* Repeated hypot avoids the avoidable overflow/underflow of sum(x*x). */
double norm = 0.0;
for (size_t i = 0; i < n; ++i) norm = std::hypot(norm, a[i]);
*out = norm;
return SLMATH_OK;
}
slmath_status slmath_vector_normalize(const double *a, double *out, size_t n) {
if (!valid_range(a, n) || !valid_range(out, n))
return SLMATH_INVALID_ARGUMENT;
double norm = 0.0;
for (size_t i = 0; i < n; ++i) norm = std::hypot(norm, a[i]);
if (norm == 0.0 || !std::isfinite(norm)) return SLMATH_INVALID_ARGUMENT;
for (size_t i = 0; i < n; ++i) out[i] = a[i] / norm;
return SLMATH_OK;
}
slmath_status slmath_vector_cross3(const double a[3], const double b[3],
double out[3]) {
if (!a || !b || !out) return SLMATH_INVALID_ARGUMENT;
const double x = a[1] * b[2] - a[2] * b[1];
const double y = a[2] * b[0] - a[0] * b[2];
const double z = a[0] * b[1] - a[1] * b[0];
out[0] = x; out[1] = y; out[2] = z;
return SLMATH_OK;
}
slmath_status slmath_matrix_multiply(const double *a, size_t rows_a,
size_t cols_a, const double *b,
size_t rows_b, size_t cols_b,
double *out) {
if (cols_a != rows_b) return SLMATH_DIMENSION_MISMATCH;
size_t ac = 0, bc = 0, oc = 0;
if (!count_ok(rows_a, cols_a, &ac) ||
!count_ok(rows_b, cols_b, &bc) ||
!count_ok(rows_a, cols_b, &oc))
return SLMATH_SIZE_OVERFLOW;
if (!valid_range(a, ac) || !valid_range(b, bc) || !valid_range(out, oc))
return SLMATH_INVALID_ARGUMENT;
try {
std::vector<double> staged(oc, 0.0);
for (size_t r = 0; r < rows_a; ++r) {
for (size_t k = 0; k < cols_a; ++k) {
const double av = a[r * cols_a + k];
for (size_t c = 0; c < cols_b; ++c)
staged[r * cols_b + c] += av * b[k * cols_b + c];
}
}
for (size_t i = 0; i < oc; ++i) out[i] = staged[i];
} catch (...) {
/* No C++ exception may cross the stable C ABI boundary. */
return SLMATH_ALLOCATION_FAILURE;
}
return SLMATH_OK;
}
slmath_status slmath_matrix_transpose(const double *a, size_t rows,
size_t cols, double *out) {
size_t count = 0;
if (!count_ok(rows, cols, &count)) return SLMATH_SIZE_OVERFLOW;
if (!valid_range(a, count) || !valid_range(out, count))
return SLMATH_INVALID_ARGUMENT;
try {
std::vector<double> staged(count);
for (size_t r = 0; r < rows; ++r)
for (size_t c = 0; c < cols; ++c)
staged[c * rows + r] = a[r * cols + c];
for (size_t i = 0; i < count; ++i) out[i] = staged[i];
} catch (const std::bad_alloc &) {
return SLMATH_ALLOCATION_FAILURE;
}
return SLMATH_OK;
}
slmath_status slmath_matrix_identity(double *out, size_t order) {
size_t count = 0;
if (!count_ok(order, order, &count)) return SLMATH_SIZE_OVERFLOW;
if (!valid_range(out, count)) return SLMATH_INVALID_ARGUMENT;
for (size_t i = 0; i < count; ++i) out[i] = 0.0;
for (size_t i = 0; i < order; ++i) out[i * order + i] = 1.0;
return SLMATH_OK;
}
slmath_status slmath_matrix_lu(const double *a, size_t n, double *lu,
size_t *pivots, double tolerance) {
size_t count = 0;
if (!count_ok(n, n, &count)) return SLMATH_SIZE_OVERFLOW;
if (!valid_range(a, count) || !valid_range(lu, count) ||
!pivots || !std::isfinite(tolerance) || tolerance < 0.0)
return SLMATH_INVALID_ARGUMENT;
for (size_t i = 0; i < count; ++i) lu[i] = a[i];
for (size_t i = 0; i < n; ++i) pivots[i] = i;
for (size_t k = 0; k < n; ++k) {
size_t pivot = k;
double largest = std::fabs(lu[k*n+k]);
for (size_t r = k + 1; r < n; ++r) {
const double v = std::fabs(lu[r*n+k]);
if (v > largest) { largest = v; pivot = r; }
}
if (!(largest > tolerance)) return SLMATH_SINGULAR;
if (pivot != k) {
for (size_t c = 0; c < n; ++c)
std::swap(lu[k*n+c], lu[pivot*n+c]);
std::swap(pivots[k], pivots[pivot]);
}
for (size_t r = k + 1; r < n; ++r) {
lu[r*n+k] /= lu[k*n+k];
for (size_t c = k + 1; c < n; ++c)
lu[r*n+c] -= lu[r*n+k] * lu[k*n+c];
}
}
return SLMATH_OK;
}
slmath_status slmath_matrix_lu_solve(const double *lu, const size_t *pivots,
size_t n, const double *b, double *x) {
size_t count = 0;
if (!count_ok(n, n, &count)) return SLMATH_SIZE_OVERFLOW;
if (!valid_range(lu, count) || !valid_range(b, n) ||
!valid_range(x, n) || !pivots) return SLMATH_INVALID_ARGUMENT;
std::vector<double> work;
try { work.resize(n); } catch (...) { return SLMATH_ALLOCATION_FAILURE; }
for (size_t i = 0; i < n; ++i) {
if (pivots[i] >= n) return SLMATH_INVALID_ARGUMENT;
work[i] = b[pivots[i]];
}
for (size_t i = 0; i < n; ++i)
for (size_t j = 0; j < i; ++j) work[i] -= lu[i*n+j] * work[j];
for (size_t ii = n; ii-- > 0;) {
for (size_t j = ii + 1; j < n; ++j)
work[ii] -= lu[ii*n+j] * work[j];
if (lu[ii*n+ii] == 0.0) return SLMATH_SINGULAR;
work[ii] /= lu[ii*n+ii];
}
for (size_t i = 0; i < n; ++i) x[i] = work[i];
return SLMATH_OK;
}
slmath_status slmath_matrix_inverse(const double *a, size_t n, double *out,
double tolerance) {
size_t count = 0;
if (!count_ok(n, n, &count)) return SLMATH_SIZE_OVERFLOW;
if (!valid_range(a, count) || !valid_range(out, count))
return SLMATH_INVALID_ARGUMENT;
std::vector<double> lu, rhs, solution, staged;
std::vector<size_t> pivots;
try {
lu.resize(count); rhs.resize(n); solution.resize(n);
staged.resize(count); pivots.resize(n);
} catch (...) { return SLMATH_ALLOCATION_FAILURE; }
slmath_status status = slmath_matrix_lu(a, n, lu.data(), pivots.data(), tolerance);
if (status != SLMATH_OK) return status;
for (size_t c = 0; c < n; ++c) {
std::fill(rhs.begin(), rhs.end(), 0.0);
rhs[c] = 1.0;
status = slmath_matrix_lu_solve(lu.data(), pivots.data(), n,
rhs.data(), solution.data());
if (status != SLMATH_OK) return status;
for (size_t r = 0; r < n; ++r) staged[r*n+c] = solution[r];
}
for (size_t i = 0; i < count; ++i) out[i] = staged[i];
return SLMATH_OK;
}
slmath_status slmath_matrix_determinant(const double *a, size_t n,
double *out, double tolerance) {
if (!out || n==0) return SLMATH_INVALID_ARGUMENT;
size_t count=0;
if (!count_ok(n,n,&count)) return SLMATH_SIZE_OVERFLOW;
if (!valid_range(a,count) || !std::isfinite(tolerance) || tolerance<0.0)
return SLMATH_INVALID_ARGUMENT;
std::vector<double> lu;
std::vector<size_t> pivots;
std::vector<unsigned char> visited;
try { lu.resize(count); pivots.resize(n); visited.assign(n,0); }
catch (...) { return SLMATH_ALLOCATION_FAILURE; }
slmath_status status=slmath_matrix_lu(a,n,lu.data(),pivots.data(),tolerance);
if (status==SLMATH_SINGULAR) { *out=0.0; return SLMATH_OK; }
if (status!=SLMATH_OK) return status;
size_t cycles=0;
for(size_t i=0;i<n;++i) if(!visited[i]) {
++cycles;
size_t j=i;
while(j<n && !visited[j]) { visited[j]=1; j=pivots[j]; }
}
double value=((n-cycles)&1u)?-1.0:1.0;
for(size_t i=0;i<n;++i) value*=lu[i*n+i];
*out=value;
return SLMATH_OK;
}
slmath_status slmath_matrix_qr(const double *a, size_t rows, size_t cols,
double *q, double *r, double tolerance) {
size_t ac = 0, qc = 0, rc = 0;
if (rows < cols) return SLMATH_DIMENSION_MISMATCH;
if (!count_ok(rows, cols, &ac) || !count_ok(rows, cols, &qc) ||
!count_ok(cols, cols, &rc)) return SLMATH_SIZE_OVERFLOW;
if (!valid_range(a, ac) || !valid_range(q, qc) || !valid_range(r, rc) ||
!std::isfinite(tolerance) || tolerance < 0.0)
return SLMATH_INVALID_ARGUMENT;
std::vector<double> qwork, rwork, v;
try { qwork.resize(qc); rwork.assign(rc, 0.0); v.resize(rows); }
catch (...) { return SLMATH_ALLOCATION_FAILURE; }
for (size_t c = 0; c < cols; ++c) {
for (size_t i = 0; i < rows; ++i) v[i] = a[i*cols+c];
for (size_t j = 0; j < c; ++j) {
double projection = 0.0;
for (size_t i = 0; i < rows; ++i)
projection += qwork[i*cols+j] * v[i];
rwork[j*cols+c] = projection;
for (size_t i = 0; i < rows; ++i)
v[i] -= projection * qwork[i*cols+j];
}
double norm = 0.0;
for (size_t i = 0; i < rows; ++i) norm = std::hypot(norm, v[i]);
if (!(norm > tolerance)) return SLMATH_SINGULAR;
rwork[c*cols+c] = norm;
for (size_t i = 0; i < rows; ++i) qwork[i*cols+c] = v[i] / norm;
}
for (size_t i = 0; i < qc; ++i) q[i] = qwork[i];
for (size_t i = 0; i < rc; ++i) r[i] = rwork[i];
return SLMATH_OK;
}
slmath_complex slmath_complex_add(slmath_complex a, slmath_complex b) {
return {a.re+b.re, a.im+b.im};
}
slmath_complex slmath_complex_subtract(slmath_complex a, slmath_complex b) {
return {a.re-b.re, a.im-b.im};
}
slmath_complex slmath_complex_multiply(slmath_complex a, slmath_complex b) {
return {a.re*b.re-a.im*b.im, a.re*b.im+a.im*b.re};
}
slmath_status slmath_complex_divide(slmath_complex a, slmath_complex b,
slmath_complex *out) {
if (!out || (b.re == 0.0 && b.im == 0.0))
return SLMATH_INVALID_ARGUMENT;
/* Smith's scaled division avoids squaring large components. */
if (std::fabs(b.re) >= std::fabs(b.im)) {
const double ratio = b.im / b.re;
const double den = b.re + b.im * ratio;
out->re = (a.re + a.im * ratio) / den;
out->im = (a.im - a.re * ratio) / den;
} else {
const double ratio = b.re / b.im;
const double den = b.im + b.re * ratio;
out->re = (a.re * ratio + a.im) / den;
out->im = (a.im * ratio - a.re) / den;
}
return SLMATH_OK;
}
double slmath_complex_abs(slmath_complex z) { return std::hypot(z.re, z.im); }
double slmath_complex_phase(slmath_complex z) { return std::atan2(z.im, z.re); }
slmath_complex slmath_complex_conjugate(slmath_complex z) { return {z.re, -z.im}; }
slmath_status slmath_array_copy(const double *src, double *dst, size_t n) {
if (!valid_range(src, n) || !valid_range(dst, n))
return SLMATH_INVALID_ARGUMENT;
if (src != dst) std::memmove(dst, src, n * sizeof(double));
return SLMATH_OK;
}
slmath_status slmath_array_slice(const double *src, size_t src_n,
size_t start, size_t count, size_t stride,
double *dst) {
if (!src || !dst || stride == 0 || start > src_n)
return SLMATH_INVALID_ARGUMENT;
if (count && (count - 1 > (std::numeric_limits<size_t>::max()-start)/stride ||
start + (count-1)*stride >= src_n))
return SLMATH_INVALID_ARGUMENT;
if (!valid_range(src, src_n) || !valid_range(dst, count))
return SLMATH_INVALID_ARGUMENT;
for (size_t i = 0; i < count; ++i) dst[i] = src[start+i*stride];
return SLMATH_OK;
}
slmath_status slmath_array_binary(const double *a, const double *b,
double *out, size_t n, int operation) {
if (operation < 0 || operation > 3) return SLMATH_INVALID_ARGUMENT;
return vector_binary(a, b, out, n, [operation](double x, double y) {
switch (operation) {
case 0: return x+y;
case 1: return x-y;
case 2: return x*y;
default: return y == 0.0 ? std::numeric_limits<double>::quiet_NaN() : x/y;
}
});
}
slmath_status slmath_symmetric_eigen(const double *a, size_t n,
double *eigenvalues, double *eigenvectors,
size_t max_sweeps, double tolerance) {
size_t count = 0;
if (!count_ok(n, n, &count)) return SLMATH_SIZE_OVERFLOW;
if (!valid_range(a, count) || !valid_range(eigenvectors, count) ||
!valid_range(eigenvalues, n) || !std::isfinite(tolerance) || tolerance < 0.0)
return SLMATH_INVALID_ARGUMENT;
for (size_t row=0; row<n; ++row) for (size_t col=row; col<n; ++col) {
if (!std::isfinite(a[row*n+col]) || !std::isfinite(a[col*n+row]) ||
std::fabs(a[row*n+col]-a[col*n+row]) > tolerance)
return SLMATH_INVALID_ARGUMENT;
}
std::vector<double> m, v;
try { m.assign(a, a+count); v.assign(count, 0.0); }
catch (...) { return SLMATH_ALLOCATION_FAILURE; }
for (size_t i = 0; i < n; ++i) v[i*n+i] = 1.0;
for (size_t sweep = 0; sweep < max_sweeps; ++sweep) {
double largest = 0.0;
for (size_t p = 0; p < n; ++p)
for (size_t q = p+1; q < n; ++q)
largest = std::max(largest, std::fabs(m[p*n+q]));
if (largest <= tolerance) {
for (size_t i = 0; i < n; ++i) eigenvalues[i] = m[i*n+i];
for (size_t i = 0; i < count; ++i) eigenvectors[i] = v[i];
return SLMATH_OK;
}
for (size_t p = 0; p < n; ++p) for (size_t q = p+1; q < n; ++q) {
const double apq = m[p*n+q];
if (std::fabs(apq) <= tolerance) continue;
const double tau = (m[q*n+q]-m[p*n+p])/(2.0*apq);
const double t = (tau >= 0.0 ? 1.0 : -1.0) /
(std::fabs(tau)+std::hypot(1.0,tau));
const double c = 1.0/std::hypot(1.0,t);
const double s = t*c;
const double app=m[p*n+p], aqq=m[q*n+q];
m[p*n+p]=app-t*apq; m[q*n+q]=aqq+t*apq;
m[p*n+q]=m[q*n+p]=0.0;
for (size_t k=0;k<n;++k) if(k!=p && k!=q) {
const double mkp=m[k*n+p], mkq=m[k*n+q];
m[k*n+p]=m[p*n+k]=c*mkp-s*mkq;
m[k*n+q]=m[q*n+k]=s*mkp+c*mkq;
}
for (size_t k=0;k<n;++k) {
const double vkp=v[k*n+p], vkq=v[k*n+q];
v[k*n+p]=c*vkp-s*vkq;
v[k*n+q]=s*vkp+c*vkq;
}
}
}
return SLMATH_NO_CONVERGENCE; /* Did not converge within caller's sweep budget. */
}
slmath_status slmath_fft(slmath_complex *values, size_t n, int inverse) {
if (!values || n == 0 || (n & (n-1)) != 0 || (inverse != 0 && inverse != 1))
return SLMATH_INVALID_ARGUMENT;
if (n > std::numeric_limits<size_t>::max()/sizeof(slmath_complex))
return SLMATH_SIZE_OVERFLOW;
for (size_t i=1,j=0;i<n;++i) {
size_t bit=n>>1;
for (; j&bit; bit>>=1) j^=bit;
j^=bit;
if (i<j) std::swap(values[i],values[j]);
}
const double pi=3.1415926535897932384626433832795;
for (size_t len=2;len<=n;len<<=1) {
const double angle=(inverse?2.0:-2.0)*pi/static_cast<double>(len);
const slmath_complex root={std::cos(angle),std::sin(angle)};
for (size_t base=0;base<n;base+=len) {
slmath_complex w={1.0,0.0};
for (size_t j=0;j<len/2;++j) {
const slmath_complex even=values[base+j];
const slmath_complex odd=slmath_complex_multiply(values[base+j+len/2],w);
values[base+j]=slmath_complex_add(even,odd);
values[base+j+len/2]=slmath_complex_subtract(even,odd);
w=slmath_complex_multiply(w,root);
}
}
if (len > n/2) break; /* Prevent size_t shift overflow at the top stage. */
}
if (inverse) for(size_t i=0;i<n;++i) {
values[i].re/=static_cast<double>(n);
values[i].im/=static_cast<double>(n);
}
return SLMATH_OK;
}
slmath_status slmath_vm_dispatch(slmath_operation operation,
const slmath_buffer *a,
const slmath_buffer *b,
slmath_buffer *out,
slmath_buffer *aux,
double scalar, size_t flags) {
if (!a || !out || !a->data || !out->data)
return SLMATH_INVALID_ARGUMENT;
size_t a_shape = 0, out_shape = 0, b_shape = 0, aux_shape = 0;
if (!count_ok(a->rows,a->cols,&a_shape) ||
!count_ok(out->rows,out->cols,&out_shape))
return SLMATH_SIZE_OVERFLOW;
if (a->rows && a->cols && a->length < a_shape)
return SLMATH_DIMENSION_MISMATCH;
if (out->rows && out->cols && out->length < out_shape)
return SLMATH_DIMENSION_MISMATCH;
if (b && !count_ok(b->rows,b->cols,&b_shape))
return SLMATH_SIZE_OVERFLOW;
if (aux && !count_ok(aux->rows,aux->cols,&aux_shape))
return SLMATH_SIZE_OVERFLOW;
if (b && b->length < b_shape) return SLMATH_DIMENSION_MISMATCH;
if (aux && aux->length < aux_shape) return SLMATH_DIMENSION_MISMATCH;
switch (operation) {
case SLMATH_OP_VECTOR_ADD:
if (!b || !b->data || a->cols != 1 || b->cols != 1 || out->cols != 1 ||
a->rows != b->rows || out->rows != a->rows || a_shape != b_shape || out_shape < a_shape)
return SLMATH_DIMENSION_MISMATCH;
return slmath_vector_add(a->data,b->data,out->data,a_shape);
case SLMATH_OP_VECTOR_DOT:
if (!b || !b->data || a->cols != 1 || b->cols != 1 ||
out->rows != 1 || out->cols != 1 || a->rows != b->rows ||
a_shape != b_shape || out->length < 1)
return SLMATH_DIMENSION_MISMATCH;
return slmath_vector_dot(a->data,b->data,a_shape,out->data);
case SLMATH_OP_VECTOR_NORM:
if (a->cols != 1 || out->rows != 1 || out->cols != 1 || out->length < 1)
return SLMATH_DIMENSION_MISMATCH;
return slmath_vector_norm(a->data,a_shape,out->data);
case SLMATH_OP_VECTOR_SCALE:
if (a->cols != 1 || out->cols != 1 || out->rows != a->rows || out_shape < a_shape)
return SLMATH_DIMENSION_MISMATCH;
return slmath_vector_scale(a->data,scalar,out->data,a_shape);
case SLMATH_OP_VECTOR_SUBTRACT:
if (!b || !b->data || a->cols != 1 || b->cols != 1 || out->cols != 1 ||
a->rows != b->rows || out->rows != a->rows ||
a_shape != b_shape || out_shape < a_shape)
return SLMATH_DIMENSION_MISMATCH;
return slmath_vector_subtract(a->data,b->data,out->data,a_shape);
case SLMATH_OP_VECTOR_NORMALIZE:
if (a->cols != 1 || out->cols != 1 || out->rows != a->rows || out_shape < a_shape)
return SLMATH_DIMENSION_MISMATCH;
return slmath_vector_normalize(a->data,out->data,a_shape);
case SLMATH_OP_VECTOR_CROSS3:
if (!b || !b->data || a->rows != 3 || a->cols != 1 ||
b->rows != 3 || b->cols != 1 || out->rows != 3 || out->cols != 1 ||
a->length < 3 || b->length < 3 || out->length < 3)
return SLMATH_DIMENSION_MISMATCH;
return slmath_vector_cross3(a->data,b->data,out->data);
case SLMATH_OP_COMPLEX_ABS:
case SLMATH_OP_COMPLEX_PHASE:
if (a->rows != 2 || a->cols != 1 || out->rows != 1 || out->cols != 1 ||
a->length < 2 || out->length < 1) return SLMATH_DIMENSION_MISMATCH;
{
const slmath_complex z={a->data[0],a->data[1]};
out->data[0]=(operation==SLMATH_OP_COMPLEX_ABS)
?slmath_complex_abs(z):slmath_complex_phase(z);
}
return SLMATH_OK;
case SLMATH_OP_COMPLEX_CONJUGATE:
if (a->rows != 2 || a->cols != 1 || out->rows != 2 || out->cols != 1 ||
a->length < 2 || out->length < 2) return SLMATH_DIMENSION_MISMATCH;
{
const slmath_complex z=slmath_complex_conjugate({a->data[0],a->data[1]});
out->data[0]=z.re; out->data[1]=z.im;
}
return SLMATH_OK;
case SLMATH_OP_COMPLEX_ADD:
case SLMATH_OP_COMPLEX_SUBTRACT:
case SLMATH_OP_COMPLEX_MULTIPLY:
case SLMATH_OP_COMPLEX_DIVIDE:
if (!b || !b->data || a->rows != 2 || a->cols != 1 ||
b->rows != 2 || b->cols != 1 || out->rows != 2 || out->cols != 1 ||
a->length < 2 || b->length < 2 || out->length < 2)
return SLMATH_DIMENSION_MISMATCH;
{
const slmath_complex x={a->data[0],a->data[1]};
const slmath_complex y={b->data[0],b->data[1]};
slmath_complex z{};
if (operation == SLMATH_OP_COMPLEX_ADD) z=slmath_complex_add(x,y);
else if (operation == SLMATH_OP_COMPLEX_SUBTRACT) z=slmath_complex_subtract(x,y);
else if (operation == SLMATH_OP_COMPLEX_MULTIPLY) z=slmath_complex_multiply(x,y);
else {
slmath_status status=slmath_complex_divide(x,y,&z);
if(status!=SLMATH_OK) return status;
}
out->data[0]=z.re; out->data[1]=z.im;
}
return SLMATH_OK;
case SLMATH_OP_MATRIX_MULTIPLY:
if (!b || !b->data || a->cols != b->rows ||
a->length < a_shape || b->length < b_shape ||
out->rows != a->rows || out->cols != b->cols ||
out->length < out_shape)
return SLMATH_DIMENSION_MISMATCH;
return slmath_matrix_multiply(a->data,a->rows,a->cols,b->data,
b->rows,b->cols,out->data);
case SLMATH_OP_MATRIX_TRANSPOSE:
if (a->length < a_shape || out->rows != a->cols ||
out->cols != a->rows || out->length < out_shape)
return SLMATH_DIMENSION_MISMATCH;
return slmath_matrix_transpose(a->data,a->rows,a->cols,out->data);
case SLMATH_OP_MATRIX_DETERMINANT:
if (a->rows != a->cols || a->length < a_shape ||
out->rows != 1 || out->cols != 1 || out->length < 1)
return SLMATH_DIMENSION_MISMATCH;
return slmath_matrix_determinant(a->data,a->rows,out->data,scalar);
case SLMATH_OP_MATRIX_INVERSE:
if (a->rows != a->cols || a->length < a_shape ||
out->rows != a->rows || out->cols != a->cols ||
out->length < out_shape)
return SLMATH_DIMENSION_MISMATCH;
return slmath_matrix_inverse(a->data,a->rows,out->data,scalar);
case SLMATH_OP_QR:
if (!aux || !aux->data || a->rows < a->cols ||
a->length < a_shape ||
out->rows != a->rows || out->cols != a->cols ||
out->length < a_shape ||
aux->rows != a->cols || aux->cols != a->cols ||
aux->length < aux_shape)
return SLMATH_DIMENSION_MISMATCH;
return slmath_matrix_qr(a->data,a->rows,a->cols,out->data,
aux->data,scalar);
case SLMATH_OP_SYMMETRIC_EIGEN:
if (!aux || !aux->data || a->rows != a->cols ||
a->length < a_shape || out->rows != 1 || out->cols != a->rows ||
out->length < a->rows || aux->rows != a->rows || aux->cols != a->rows ||
aux->length < a_shape)
return SLMATH_DIMENSION_MISMATCH;
return slmath_symmetric_eigen(a->data,a->rows,out->data,aux->data,
flags,scalar);
case SLMATH_OP_FFT:
if (flags > 1) return SLMATH_INVALID_ARGUMENT;
if (a->cols != 1 || out->cols != 1 || out->rows != a->rows ||
a_shape == 0 || (a_shape % 2) != 0 ||
out_shape < a_shape || a->length < a_shape)
return SLMATH_DIMENSION_MISMATCH;
if (out->data != a->data)
std::memmove(out->data,a->data,a_shape*sizeof(double));
return slmath_fft(reinterpret_cast<slmath_complex*>(out->data),
a_shape/2,(int)flags);
default:
return SLMATH_INVALID_ARGUMENT;
}
}
} // extern "C"