292 lines
7.6 KiB
C++
292 lines
7.6 KiB
C++
//
|
|
// File: cwt.cpp
|
|
//
|
|
// MATLAB Coder version : 4.3
|
|
// C/C++ source code generated on : 30-Mar-2020 11:59:32
|
|
//
|
|
|
|
// Include Files
|
|
#include "cwt.h"
|
|
#include "cwt_data.h"
|
|
#include "cwt_emxutil.h"
|
|
#include "cwt_initialize.h"
|
|
#include "cwtfilterbank.h"
|
|
#include "rt_defines.h"
|
|
#include "rt_nonfinite.h"
|
|
#include <cmath>
|
|
#include <cstring>
|
|
#include <math.h>
|
|
#include <string.h>
|
|
|
|
// Function Declarations
|
|
static double rt_atan2d_snf(double u0, double u1);
|
|
static double rt_hypotd_snf(double u0, double u1);
|
|
|
|
// Function Definitions
|
|
|
|
//
|
|
// Arguments : double u0
|
|
// double u1
|
|
// Return Type : double
|
|
//
|
|
static double rt_atan2d_snf(double u0, double u1)
|
|
{
|
|
double y;
|
|
int b_u0;
|
|
int b_u1;
|
|
if (rtIsNaN(u0) || rtIsNaN(u1)) {
|
|
y = rtNaN;
|
|
} else if (rtIsInf(u0) && rtIsInf(u1)) {
|
|
if (u0 > 0.0) {
|
|
b_u0 = 1;
|
|
} else {
|
|
b_u0 = -1;
|
|
}
|
|
|
|
if (u1 > 0.0) {
|
|
b_u1 = 1;
|
|
} else {
|
|
b_u1 = -1;
|
|
}
|
|
|
|
y = atan2(static_cast<double>(b_u0), static_cast<double>(b_u1));
|
|
} else if (u1 == 0.0) {
|
|
if (u0 > 0.0) {
|
|
y = RT_PI / 2.0;
|
|
} else if (u0 < 0.0) {
|
|
y = -(RT_PI / 2.0);
|
|
} else {
|
|
y = 0.0;
|
|
}
|
|
} else {
|
|
y = atan2(u0, u1);
|
|
}
|
|
|
|
return y;
|
|
}
|
|
|
|
//
|
|
// Arguments : double u0
|
|
// double u1
|
|
// Return Type : double
|
|
//
|
|
static double rt_hypotd_snf(double u0, double u1)
|
|
{
|
|
double y;
|
|
double a;
|
|
a = std::abs(u0);
|
|
y = std::abs(u1);
|
|
if (a < y) {
|
|
a /= y;
|
|
y *= std::sqrt(a * a + 1.0);
|
|
} else if (a > y) {
|
|
y /= a;
|
|
y = a * std::sqrt(y * y + 1.0);
|
|
} else {
|
|
if (!rtIsNaN(y)) {
|
|
y = a * 1.4142135623730951;
|
|
}
|
|
}
|
|
|
|
return y;
|
|
}
|
|
|
|
//
|
|
// Arguments : const double x_data[]
|
|
// const int x_size[2]
|
|
// emxArray_real_T *phase
|
|
// Return Type : void
|
|
//
|
|
void cwt(const double x_data[], const int x_size[2], emxArray_real_T *phase)
|
|
{
|
|
cwtfilterbank fb;
|
|
int b_x_size[2];
|
|
int loop_ub;
|
|
double b_x_data[1280];
|
|
emxArray_creal_T *cfs;
|
|
emxArray_creal_T *max_s;
|
|
int m;
|
|
int n;
|
|
int i;
|
|
boolean_T SCALEA;
|
|
double ma;
|
|
boolean_T SCALEB;
|
|
double x;
|
|
double absbi;
|
|
double absai;
|
|
double absbr;
|
|
double Ma;
|
|
if (isInitialized_cwt == false) {
|
|
cwt_initialize();
|
|
}
|
|
|
|
emxInitStruct_cwtfilterbank(&fb);
|
|
cwtfilterbank_cwtfilterbank(&fb, static_cast<double>(x_size[1]));
|
|
b_x_size[0] = 1;
|
|
b_x_size[1] = x_size[1];
|
|
loop_ub = x_size[0] * x_size[1] - 1;
|
|
if (0 <= loop_ub) {
|
|
std::memcpy(&b_x_data[0], &x_data[0], (loop_ub + 1) * sizeof(double));
|
|
}
|
|
|
|
emxInit_creal_T(&cfs, 2);
|
|
emxInit_creal_T(&max_s, 2);
|
|
cwtfilterbank_wt(&fb, b_x_data, b_x_size, cfs);
|
|
m = cfs->size[0];
|
|
n = cfs->size[1];
|
|
i = max_s->size[0] * max_s->size[1];
|
|
max_s->size[0] = 1;
|
|
max_s->size[1] = cfs->size[1];
|
|
emxEnsureCapacity_creal_T(max_s, i);
|
|
if (cfs->size[1] >= 1) {
|
|
for (loop_ub = 0; loop_ub < n; loop_ub++) {
|
|
max_s->data[loop_ub] = cfs->data[cfs->size[0] * loop_ub];
|
|
for (i = 2; i <= m; i++) {
|
|
if (rtIsNaN(cfs->data[(i + cfs->size[0] * loop_ub) - 1].re) || rtIsNaN
|
|
(cfs->data[(i + cfs->size[0] * loop_ub) - 1].im)) {
|
|
SCALEA = false;
|
|
} else if (rtIsNaN(max_s->data[loop_ub].re) || rtIsNaN(max_s->
|
|
data[loop_ub].im)) {
|
|
SCALEA = true;
|
|
} else {
|
|
ma = std::abs(max_s->data[loop_ub].re);
|
|
if ((ma > 8.9884656743115785E+307) || (std::abs(max_s->data[loop_ub].
|
|
im) > 8.9884656743115785E+307)) {
|
|
SCALEA = true;
|
|
} else {
|
|
SCALEA = false;
|
|
}
|
|
|
|
if ((std::abs(cfs->data[(i + cfs->size[0] * loop_ub) - 1].re) >
|
|
8.9884656743115785E+307) || (std::abs(cfs->data[(i + cfs->size[0]
|
|
* loop_ub) - 1].im) > 8.9884656743115785E+307)) {
|
|
SCALEB = true;
|
|
} else {
|
|
SCALEB = false;
|
|
}
|
|
|
|
if (SCALEA || SCALEB) {
|
|
x = rt_hypotd_snf(max_s->data[loop_ub].re / 2.0, max_s->data[loop_ub]
|
|
.im / 2.0);
|
|
absbi = rt_hypotd_snf(cfs->data[(i + cfs->size[0] * loop_ub) - 1].re
|
|
/ 2.0, cfs->data[(i + cfs->size[0] * loop_ub)
|
|
- 1].im / 2.0);
|
|
} else {
|
|
x = rt_hypotd_snf(max_s->data[loop_ub].re, max_s->data[loop_ub].im);
|
|
absbi = rt_hypotd_snf(cfs->data[(i + cfs->size[0] * loop_ub) - 1].re,
|
|
cfs->data[(i + cfs->size[0] * loop_ub) - 1].im);
|
|
}
|
|
|
|
if (x == absbi) {
|
|
absai = std::abs(max_s->data[loop_ub].im);
|
|
absbr = std::abs(cfs->data[(i + cfs->size[0] * loop_ub) - 1].re);
|
|
absbi = std::abs(cfs->data[(i + cfs->size[0] * loop_ub) - 1].im);
|
|
if (ma > absai) {
|
|
Ma = ma;
|
|
ma = absai;
|
|
} else {
|
|
Ma = absai;
|
|
}
|
|
|
|
if (absbr > absbi) {
|
|
absai = absbr;
|
|
absbr = absbi;
|
|
} else {
|
|
absai = absbi;
|
|
}
|
|
|
|
if (Ma > absai) {
|
|
if (ma < absbr) {
|
|
x = Ma - absai;
|
|
absbi = (ma / 2.0 + absbr / 2.0) / (Ma / 2.0 + absai / 2.0) *
|
|
(absbr - ma);
|
|
} else {
|
|
x = Ma;
|
|
absbi = absai;
|
|
}
|
|
} else if (Ma < absai) {
|
|
if (ma > absbr) {
|
|
absbi = absai - Ma;
|
|
x = (ma / 2.0 + absbr / 2.0) / (Ma / 2.0 + absai / 2.0) * (ma -
|
|
absbr);
|
|
} else {
|
|
x = Ma;
|
|
absbi = absai;
|
|
}
|
|
} else {
|
|
x = ma;
|
|
absbi = absbr;
|
|
}
|
|
|
|
if (x == absbi) {
|
|
x = rt_atan2d_snf(max_s->data[loop_ub].im, max_s->data[loop_ub].re);
|
|
absbi = rt_atan2d_snf(cfs->data[(i + cfs->size[0] * loop_ub) - 1].
|
|
im, cfs->data[(i + cfs->size[0] * loop_ub) -
|
|
1].re);
|
|
if (x == absbi) {
|
|
absbi = cfs->data[(i + cfs->size[0] * loop_ub) - 1].re;
|
|
absai = cfs->data[(i + cfs->size[0] * loop_ub) - 1].im;
|
|
if (x > 0.78539816339744828) {
|
|
if (x > 2.3561944901923448) {
|
|
x = -max_s->data[loop_ub].im;
|
|
absbi = -absai;
|
|
} else {
|
|
x = -max_s->data[loop_ub].re;
|
|
absbi = -absbi;
|
|
}
|
|
} else if (x > -0.78539816339744828) {
|
|
x = max_s->data[loop_ub].im;
|
|
absbi = absai;
|
|
} else if (x > -2.3561944901923448) {
|
|
x = max_s->data[loop_ub].re;
|
|
} else {
|
|
x = -max_s->data[loop_ub].im;
|
|
absbi = -absai;
|
|
}
|
|
|
|
if (x == absbi) {
|
|
x = 0.0;
|
|
absbi = 0.0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SCALEA = (x < absbi);
|
|
}
|
|
|
|
if (SCALEA) {
|
|
max_s->data[loop_ub] = cfs->data[(i + cfs->size[0] * loop_ub) - 1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
emxFree_creal_T(&cfs);
|
|
i = phase->size[0] * phase->size[1];
|
|
phase->size[0] = 1;
|
|
phase->size[1] = max_s->size[1];
|
|
emxEnsureCapacity_real_T(phase, i);
|
|
loop_ub = max_s->size[1];
|
|
for (i = 0; i < loop_ub; i++) {
|
|
phase->data[i] = 0.0;
|
|
}
|
|
|
|
i = max_s->size[1];
|
|
for (loop_ub = 0; loop_ub < i; loop_ub++) {
|
|
phase->data[loop_ub] = std::atan(max_s->data[loop_ub].im / max_s->
|
|
data[loop_ub].re);
|
|
}
|
|
|
|
emxFree_creal_T(&max_s);
|
|
|
|
//
|
|
emxFreeStruct_cwtfilterbank(&fb);
|
|
}
|
|
|
|
//
|
|
// File trailer for cwt.cpp
|
|
//
|
|
// [EOF]
|
|
//
|