115 lines
2.9 KiB
C
115 lines
2.9 KiB
C
#ifndef INCLUDED_C_COMPLEX_H
|
|
#define INCLUDED_C_COMPLEX_H
|
|
|
|
#ifndef INCLUDED_C_BASE_H
|
|
#include <c_Base.h>
|
|
#endif /*INCLUDED_C_BASE_H*/
|
|
|
|
#ifndef INCLUDED_MATH_H
|
|
#define INCLUDED_MATH_H
|
|
#include <math.h>
|
|
#endif /*INCLUDED_MATH_H*/
|
|
|
|
/* ------------------------------------------------------------------------------------------------------------------ */
|
|
/* */
|
|
|
|
|
|
typedef struct {
|
|
double real; // Real component field
|
|
double imag; // Imaginary component field
|
|
} c_Complex_t;
|
|
|
|
/* ------------------------------------------------------------------------------------------------------------------ */
|
|
/* */
|
|
|
|
/**
|
|
* Factory Primitive: Construct a new complex number on the stack frame.
|
|
*/
|
|
C_STATIC_FORCE_INLINE
|
|
c_Complex_t c_Complex_Create(double real, double imag) {
|
|
c_Complex_t c;
|
|
c.real = real;
|
|
c.imag = imag;
|
|
return c;
|
|
}
|
|
|
|
/**
|
|
* Complex Addition: returns (a + b) by value.
|
|
* Time Complexity: O(1) | Space Complexity: O(1) on stack
|
|
*/
|
|
C_STATIC_FORCE_INLINE
|
|
c_Complex_t c_Complex_Add(c_Complex_t a, c_Complex_t b) {
|
|
c_Complex_t res;
|
|
res.real = a.real + b.real;
|
|
res.imag = a.imag + b.imag;
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Complex Subtraction: returns (a - b) by value.
|
|
* Time Complexity: O(1) | Space Complexity: O(1) on stack
|
|
*/
|
|
C_STATIC_FORCE_INLINE
|
|
c_Complex_t c_Complex_Sub(c_Complex_t a, c_Complex_t b) {
|
|
c_Complex_t res;
|
|
res.real = a.real - b.real;
|
|
res.imag = a.imag - b.imag;
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Complex Multiplication: returns (a * b) by value.
|
|
* Time Complexity: O(1) | Space Complexity: O(1) on stack
|
|
*/
|
|
C_STATIC_FORCE_INLINE
|
|
c_Complex_t c_Complex_Mul(c_Complex_t a, c_Complex_t b) {
|
|
c_Complex_t res;
|
|
res.real = a.real * b.real - a.imag * b.imag;
|
|
res.imag = a.real * b.imag + a.imag * b.real;
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Complex Division: returns (a / b) by value.
|
|
* Features a safety check to intercept division-by-zero boundary exceptions.
|
|
*
|
|
* Time Complexity: O(1) | Space Complexity: O(1) on stack
|
|
*/
|
|
C_STATIC_FORCE_INLINE
|
|
c_err_t c_Complex_Div(c_Complex_t a, c_Complex_t b, c_Complex_t* out_res) {
|
|
if (out_res == NULL) return C_ERR_PARAM;
|
|
|
|
double denom = b.real * b.real + b.imag * b.imag;
|
|
if (denom == 0.0) {
|
|
out_res->real = 0.0;
|
|
out_res->imag = 0.0;
|
|
return C_ERR_INVALID; // Catch division by zero anomalies
|
|
}
|
|
|
|
out_res->real = (a.real * b.real + a.imag * b.imag) / denom;
|
|
out_res->imag = (a.imag * b.real - a.real * b.imag) / denom;
|
|
return C_ERR_OK;
|
|
}
|
|
|
|
/**
|
|
* Complex Conjugate: returns the conjugate of a (a.real - i * a.imag).
|
|
*/
|
|
C_STATIC_FORCE_INLINE
|
|
c_Complex_t c_Complex_Conjugate(c_Complex_t a) {
|
|
c_Complex_t res;
|
|
res.real = a.real;
|
|
res.imag = -a.imag;
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Complex Absolute Value (Magnitude): returns sqrt(a.real^2 + a.imag^2).
|
|
*/
|
|
C_STATIC_FORCE_INLINE
|
|
double c_Complex_Abs(c_Complex_t a) {
|
|
return sqrt(a.real * a.real + a.imag * a.imag);
|
|
}
|
|
|
|
|
|
#endif /*INCLUDED_C_COMPLEX_H*/
|