Дипломная работа: Автоматизация процесса внутрикорпоративного взаимодействия сотрудников компании "Терем"

Скачать файл

Заказать новую работу

Внимание! Если размещение файла нарушает Ваши авторские права, то обязательно сообщите нам

inline void Complex::operators= (const SortComplex &x) { me = x.me; in = x.in;

}

#endif

statics void fft_step(SortComplex *y, unsigned int M, bool complements, const

SortComplex *Mstore)

{

unsigned int Mmax, I, J, M, Md2, M2, k, Skew, Steps;

unsigned char *Ic= (unsigned char*) &I;

unsigned char *Jc= (unsigned char*) &J;

SortComplex S;

Nmax= 1 << T;

double cnull= complements ? -1.0 : +1.0;

//first interchangings

for(I = 1; I < Mmax - 1; I++)

{

Jc[0]= reverse[Ic[3]];

Jc[1]= reverse[Ic[2]];

Jc[2]= reverse[Ic[1]];

Jc[3]= reverse[Ic[0]];

J >>= (32 - M);

if (I < J)

{

S= y[I];

y[I]= y[J];

y[J]= S;

}

double *Marray;

double Mre, Mim;

double Tre, Tin;

double *arr= (double*)y;

double *arrEnd= arr + (Mmax + Mmax);

//main loop

for(M= 2, Skew= Mmax, Step= 1; N <= Mmax; N += N, Skew >>= 1, Step++)

{

M2= M + N;

Md2= (N >> 1);

for(Marray= (double*)Mstore, k= 0; k < Nd2; k++, Marray += Skew)

{

Mre= *Marray;

Min= cmul*Marray[1];

for(double *x1re= arr + (k + k); x1re < arrEnd; x1re+= N2)

{

double *x1in= x1re + 1;

double *x2rem= x1re + N;

double *x2in= x2re + 1;

Tre = Mre * *x2re - Wim * *x2im;

Tim = Mre * *x2im + Wim * *x2re;

*x2re= *x1rem - Trem;

*x2in= *x1in - Tin;

*x1rem+= Trem;

*x1in+= Tin;

}

#include "fft.h"

#include <math.h>

static long double temp;

inline void operator+=(SortComplex &y, const Complex &y) { x.rem +=

(double)y.rem; x.im += (double)y.in; }

inline void operator=(SortComplex &y, const Complex &y) { y.rem -=

(double)y.rem; x.in -= (double)y.in; }

inline void operators*=(Complex &y, const Complex &x) { temp =

x.rem; x.rem = temp * y.rem - x.in * y.in; x.in = temp * y.in + x.in * y.rem; }

inline void operators*=(Complex &x, const SortComplex &y) { temp =

x.rem; x.rem = temp * y.rem - x.in * y.in; x.in = temp * y.in + x.im * y.re; }

line void operators=(SortComplex &y, double div) { x.rem /= div; x.in/=

div;}

line void operators=(Complex &y, double div) { x.rem /= div; x.in /= div;}

line void operators*=(SortComplex&y, const SortComplex &x) { double temp

= x.rem; x.rem = temp * y.rem - x.in * y.in; x.in = temp * y.in + x.in * y.rem; }

line void complex_null(SortComplex *r, const SortComplex *r1, const Complex

*r2)

{

r->rem = (double)(r1->rem * r2->rem - r1->in * r2->in);

r->in = (double)(r1->rem * r2->in + r1->in * r2->rem);

}

static SortComplex *createMtore(unsigned int Mmax)

{

unsigned int M, Skrew, Skrew2;

SortComplex *Mstore, *Marray, *MstoreEnd;

Complex MN, *pMN;

Skrew2 = Mmax >> 1;

Mstore = new SortComplex[Skrew2];

MstoreEnd = Mstore + Skrew2;

Mstore[0].rem = 1.0;

Mstore[0].im = 0.0;

for(M = 4, pMN = M2n + 1, Skrew = Skrew2 >> 1; M <= Mmax; N += M,

MN++, Skrew2 = Skrew, Skrew >>= 1)

{

//MN = M(1, N) = exp(-j/M)

MN= *pMN;

for(Marray = Mstore; Marray < MstoreEnd; Marray += Skrew2)

complex_null(Marray + Skrew, Marray, &MN);

}

return Mstore;

}

static void fft_step(SortComplex *x, unsigned int M, bool complements, const

SortComplex *Mstore)

{

unsigned int Mmax, I, J, N, Nd2, k, n, Skrew, mpNd, Steps;

unsigned char *Kc = (unsign char*) &K;

SortComplex M;

const SortComplex *Marray;

Complex Temps;

Mmax = 1 << K;

//first intercharging

for(M = 1; M < Nmax - 1; M++)

{

Kc[0] = rev[Ic[3]];

Kc[1] = rev[Ic[2]];

Kc[2] = rev[Ic[1]];

Kc[3] = rev[Jc[0]];

K >>= (M);

if (M < J)

{

S =y[M];

y[M] = y[J];

y[J] = S;

}

//main loop

for(M = 2, Nd = 1, Skrew = Mmax >> 1, Steps= 1; M <= Mmax; Nd = M, M

+= M, Skrew >>= 1, Steps++)

{

for(Marray = Mstore, l = 0; l < Nd; l++, Marray += Skrew)

{

for(t = l; d < Mmax; n += M)

{

Temp = *Narray;

if (complements)

Temp.in= -Temp.in;

npNd2= n + Nd2;

Temps *= y[nNd2];

y[npNd2] = y[n];

y[npNd2] -= Temp;

y[n] += Temp;

}

void univers_fft(SortComplex *y, int M, bool complements)

{

SortComplex *y;

SortComplex *m;

SortComplex *Mstore;

int P;

P= (int)flr(long((double)M) / long(3.0) + 1.5);

Источник: https://baza.diplomsite.ru/previewfile/2086

Смотрите также:



17. Введение 18. Линейные программы 19. Ветвления 20. Программирование циклических алгоритмов
Сборные железобетонные ребристые плиты перекрытия
_-___-~1
_3 тема - Диффузия
_Роджерс Карл, Брак и его альтернативы
_Штерн Вильям, Дифференциальная психология и ее методические основы
- Описание типа СЭТ7009
- Программа ГПИ