Mat CmSaliencyRC::GetSR(CMat &img3f)
{
Size sz(64, 64);
Mat img1f[2], sr1f, cmplxSrc2f, cmplxDst2f;
cvtColor(img3f, img1f[1], CV_BGR2GRAY);
resize(img1f[1], img1f[0], sz, 0, 0, CV_INTER_AREA);
img1f[1] = Mat::zeros(sz, CV_32F);
merge(img1f, 2, cmplxSrc2f);
dft(cmplxSrc2f, cmplxDst2f);
AbsAngle(cmplxDst2f, img1f[0], img1f[1]);
log(img1f[0], img1f[0]);
blur(img1f[0], sr1f, Size(3, 3));
sr1f = img1f[0] - sr1f;
exp(sr1f, sr1f);
GetCmplx(sr1f, img1f[1], cmplxDst2f);
dft(cmplxDst2f, cmplxSrc2f, DFT_INVERSE | DFT_SCALE);
split(cmplxSrc2f, img1f);
pow(img1f[0], 2, img1f[0]);
pow(img1f[1], 2, img1f[1]);
img1f[0] += img1f[1];
GaussianBlur(img1f[0], img1f[0], Size(3, 3), 0);
normalize(img1f[0], img1f[0], 0, 1, NORM_MINMAX);
resize(img1f[0], img1f[1], img3f.size(), 0, 0, INTER_CUBIC);
return img1f[1];
}
/*
degraded : degraded input image
filter : filter which caused degradation
snr : signal to noise ratio of the input image
return : restorated output image
*/
Mat Dip4::wienerFilter(Mat& degraded, Mat& filter, double snr){
// be sure not to touch them
degraded = degraded.clone();
filter = filter.clone();
// Q_k = conjugate_transpose(P_k) / | P_k | ^2 + 1/SNR^2
Mat filterFreq = Mat(filter.size(), CV_32F);
Mat planesFilter[] = {filterFreq, Mat::zeros(filterFreq.size(), CV_32F)};
merge(planesFilter, 2, filterFreq);
dft(filterFreq, filterFreq, DFT_COMPLEX_OUTPUT); // filterFreq == P
// create Q
split(filterFreq, planesFilter);
Mat Re = planesFilter[0];
Mat Im = planesFilter[1];
Mat QRe = Re.clone();
Mat QIm = Im.clone();
for (int x = 0; x < filterFreq.rows; x++) for (int y = 0; y < filterFreq.cols; y++) {
// A*_ij = Ã_ji
float reConjugateTranspose = Re.at<float>(y, x);
float imConjugateTranspose = -Im.at<float>(y, x);
float resq = Re.at<float>(x, y) * Re.at<float>(x, y);
float imsq = Im.at<float>(x, y) * Im.at<float>(x, y);
float absreim = sqrt(resq + imsq);
QRe.at<float>(x, y) = reConjugateTranspose / (absreim * absreim + 1/(snr * snr));
QIm.at<float>(x, y) = imConjugateTranspose / (absreim * absreim + 1/(snr * snr));
}
Mat Q = Mat::zeros(filterFreq.size(), CV_32F);
Mat qplanes[] = {QRe, QIm};
merge(qplanes, 2, Q);
Mat original;
dft(Q, Q, DFT_INVERSE + DFT_SCALE);
split(Q, planes);
filter2D(degraded, original, -1, planes[0]);
normalize(original, original, 0, 255, CV_MINMAX);
original.convertTo(original, CV_8UC1);
return original;
}
int main()
{
int N;
std::scanf("%d", &N);
read_number(N, num_a);
read_number(N, num_b);
int p = 1;
while(p < N) p <<= 1;
N = p << 1;
init_epsilon(N);
dft(N, num_a, 0, 1, epsilon);
dft(N, num_b, 0, 1, epsilon);
for(int i = 0; i != N; ++i)
num_a[i] *= num_b[i];
dft(N, num_a, 0, 1, arti_epsilon);
for(int i = 0; i != N; ++i)
ans[i] = int(num_a[i].real() / N + 1.0e-9);
for(int i = 0; i <= N; ++i)
{
ans[i + 1] += ans[i] / 10;
ans[i] %= 10;
}
int len = N + 1;
while(!ans[len] && len) --len;
for(int i = len; i >= 0; --i)
std::printf("%c", char(ans[i] + '0'));
return 0;
}
void check_blink(){
max_input=0;
BB_flag=0;
X=dft();
if(X>FThreshold){
if(ON /*&& max_input>110*/){
big_blink=1;
}
else if(max_input>120){//see the max adc val corresssponding to saturation output of eog ckt
for(i=0;i<4;i++){
X=dft();
if(max_input>100 || max_slope>30){
BB_flag++;
}
}
if(BB_flag>0){
big_blink=1;
}
else
small_blink=1;
}
//if(X>400) big_blink=1;//big blink fourier value;same values for small and big blink
//if(counter_BigB>7) big_blink=1;//arbitrary counter
else
small_blink=1;
}
}
void run(int)
{
RNG& rng = theRNG();
for( int i = 0; i < 10; i++ )
{
int m = rng.uniform(2, 11);
int n = rng.uniform(2, 11);
int depth = rng.uniform(0, 2) + CV_32F;
Mat src8u(m, n, depth), src(m, n, depth), dst(m, n, CV_MAKETYPE(depth, 2));
Mat z = Mat::zeros(m, n, depth), dstz;
randu(src8u, Scalar::all(0), Scalar::all(10));
src8u.convertTo(src, src.type());
dst = Scalar::all(123);
Mat mv[] = {src, z}, srcz;
merge(mv, 2, srcz);
dft(srcz, dstz);
dft(src, dst, DFT_COMPLEX_OUTPUT);
if (cvtest::norm(dst, dstz, NORM_INF) > 1e-3)
{
cout << "actual:\n" << dst << endl << endl;
cout << "reference:\n" << dstz << endl << endl;
CV_Error(CV_StsError, "");
}
}
}
/************ Learn Spatio-Temporal Context Model ***********/
void STCTracker::learnSTCModel(const Mat image)
{
// step 1: Get context prior and posterior probability
getCxtPriorPosteriorModel(image);
// step 2-1: Execute 2D DFT for prior probability
Mat priorFourier;
Mat planes1[] = {cxtPriorPro, Mat::zeros(cxtPriorPro.size(), CV_64F)};
merge(planes1, 2, priorFourier);
dft(priorFourier, priorFourier);
// step 2-2: Execute 2D DFT for posterior probability
Mat postFourier;
Mat planes2[] = {cxtPosteriorPro, Mat::zeros(cxtPosteriorPro.size(), CV_64F)};
merge(planes2, 2, postFourier);
dft(postFourier, postFourier);
// step 3: Calculate the division
Mat conditionalFourier;
complexOperation(postFourier, priorFourier, conditionalFourier, 1);
// step 4: Execute 2D inverse DFT for conditional probability and we obtain STCModel
dft(conditionalFourier, STModel, DFT_INVERSE | DFT_REAL_OUTPUT | DFT_SCALE);
// step 5: Use the learned spatial context model to update spatio-temporal context model
addWeighted(STCModel, 1.0 - rho, STModel, rho, 0.0, STCModel);
}
/*
Performes a convolution by multiplication in frequency domain
in input image
kernel filter kernel
return output image
*/
Mat frequencyConvolution(Mat& in, Mat& kernel) {
const int kw = kernel.cols;
const int kh = kernel.rows;
Mat kernelBig = Mat::zeros(in.size(), in.type());
for (int x = 0; x < kw; ++x) {
for (int y = 0; y < kh; ++y) {
kernelBig.at<float>(x, y) = kernel.at<float>(x, y);
}
}
Mat kernelBigShifted = circShift(kernelBig, -(kw/2), -(kh/2));
// transform into frequency domain
Mat freqIn = Mat(in.size(), CV_32FC2); // complex
Mat freqKernel = Mat(kernelBigShifted.size(), CV_32FC2); // complex
dft(in, freqIn);
dft(kernelBigShifted, freqKernel);
// multiply in frequency domain (-> convolute in spatial domain)
Mat freqRes = Mat(kernelBig.size(), CV_32FC2); // complex
mulSpectrums(freqIn, freqKernel, freqRes, 0);
// transform back into spatial domain
Mat res(in.size(), in.type());
dft(freqRes, res, DFT_INVERSE | DFT_SCALE);
return res;
}
int main()
{
scanf("%d",&C);scanf("%c",&ch);a.clear();b.clear();
for (int i=1;i<=C;i++){a.p_b(0);b.p_b(0);}
for (int i=1;i<=C;i++){scanf("%c",&ch);a[C-i]=ch-48;}scanf("%c",&ch);
for (int i=1;i<=C;i++){scanf("%c",&ch);b[C-i]=ch-48;}
L=0,N=1;while ((N>>1)<C) N*=2,++L;
while (a.size()<N) a.p_b(0);while (b.size()<N) b.p_b(0);
/*core*/a=dft(a);b=dft(b);for (int i=0;i<N;i++) a[i]=(LL)a[i]*b[i]%bigp;a=idft(a);
for (int i=0;i<N;i++){a[i+1]=(a[i+1]+a[i]/10);a[i]%=10;}
len=N-1;while ((len>1)&&(a[len]==0)) --len;
for (int i=len;i>=0;i--) printf("%d",a[i]);printf("\n");
}
virtual int filter(const Mat &src, Mat &dest) const
{
Mat h; src.convertTo(h, CV_32F);
Mat h2(h.size(), h.type());
dft(h, h2, DFT_ROWS); // dft instead of dct solves pow2 issue
Mat h3 = (keep>0) ?
h2(Rect(0, 0, std::min(keep, h2.cols-1), 1)) :
h2;
dft(h3, dest, DCT_INVERSE | DFT_SCALE | DFT_ROWS);
return 0;
}
int main(int argc, char *argv[])
{
if(argc < 3) die("Insufficient arguments supplied.");
int length = atoll(argv[1]);
float prec = atof(argv[2]);
printf("sizeof(length) = %lu\n", sizeof(length));
float *samples = gensample(length, prec, hamming);
float *K = malloc(length*sizeof(float));
memset(K, 0, length);
float *X_real = malloc(length*sizeof(float));
memset(X_real, 0, length);
float *X_img = malloc(length*sizeof(float));
memset(X_img, 0, length);
float *result = dft(samples, length, X_real, X_img, K);
log_data(length, result, K);
free(X_real);
free(X_img);
free(K);
free(samples);
return 0;
}
int dft_test(int len,FILE* outfile) {
printf("---------------------------------------\n");
printf(" dft test \n");
printf("---------------------------------------\n");
double complex a[20] = {0.0+0.0I};
double complex b[20] = {0.0+0.0I};
double complex *pa = a, *pb = b;
for (int i = 0; i < len; i++) {
a[i] = 1.00;
dft(pa,pb,len);
fprintf(outfile, "\"case %d\"\n",i);
print_dft_case(len,pa,pb,outfile);
// fprintf(outfile,"\"case %d input\"\n",i);
// printf("input array #%d\n",i);
// print_complex_array(len,pa,outfile,"in");
// fprintf(outfile,"\"case %d output\"\n",i);
// printf("output array #%d\n",i);
// print_complex_array(len,pb,outfile,"out");
a[i] = 0.00;
}
return 0;
}
void dft(struct graph *g, struct vnode *v, int id)
{
struct enode *e;
int first;
first = 1;
v->visited = 1;
e = v->edge;
while(e != NULL)
{
if( !g->vn[e->vndx].visited)
{
if(first)
{
first = 0;
}else{
indent(id);
}
printf("-->%d", g->vn[e->vndx].item);
id += 3 + INCR(g->vn[e->vndx].item);
dft(g,&(g->vn[e->vndx]),id);
id -= 3 + INCR(g->vn[e->vndx].item);
}
e = e->next;
}
if(first)
printf("\n");
}
void fft2(Mat_<float> src)
{
int x = getOptimalDFTSize(2* src.rows );
int y = getOptimalDFTSize(2* src.cols );
copyMakeBorder(src, src, 0, (x - src.rows), 0, (y - src.cols), BORDER_CONSTANT, Scalar::all(0));
// Get padded image size
const int wx = src.cols, wy = src.rows;
const int cx = wx/2, cy = wy/2;
//--------------------------------//
// DFT - performing //
cv::Mat_<float> imgs[] = {src.clone(), Mat::zeros(src.size(), CV_32F)};
cv::Mat_<cv::Vec2f> img_dft;
merge(imgs,2,img_dft);
dft(img_dft, img_dft);
split(img_dft,imgs);
cv::Mat_<float> magnitude, phase;
cartToPolar(imgs[0],imgs[1],magnitude,phase);
dftshift(magnitude);
magnitude = magnitude + 1.0f;
log(magnitude,magnitude);
normalize(magnitude,magnitude,0,1,CV_MINMAX);
namedWindow("img_dft",WINDOW_NORMAL);
imshow("img_dft",magnitude);
waitKey(0);
cout << "out" << endl;
}
bool ImageLocationRenderer::RenderPathAndFilename(std::ostream &reply, Context &c,
const ROAnything &config)
{
ROAnything name;
if (!config.LookupPath(name, "ImageName")) {
if (config.GetType() == AnyArrayType) {
name = config[0L];
}
}
if (!name.IsNull()) {
ROAnything path;
Anything dft("/");
if (!config.LookupPath(path, "ImagePath")) {
path = c.Lookup("ImagePath");
if (path.IsNull()) {
path = dft;
}
}
Render(reply, c, path);
Render(reply, c, name);
return true;
}
return false;
}
std::vector<double> fft(std::vector<double> signal)
{
float N = signal.size();
std::vector<std::complex<double>> dft(N);
int32_t range = N/2;
//range = 40;
//int32_t range = 19;
std::complex<double> j (0.0,1.0);
for(int32_t k = -range; k<= range; k++)
{
for(uint32_t inc = 0; inc < N; inc++)
{
std::complex<double> tmp (k * (inc + 1) * 2 * PI / N, 0);
std::complex<double> tmp2 (1.0/N * signal[inc], 0);
dft[k + range] = dft[k + range] + tmp2 * pow(E_,-j * tmp);
}
}
std::vector<double> final_result(N);
for(uint32_t i = 0; i< N; ++i )
{
final_result[i] = abs(dft[i]);
}
return final_result;
}
void TransformDecoding(float pDataMatrix[N_TRANS_DECODER_IN_MAX], float pDecSeq[N_TRANS_DECODER_OUT_MAX], int NumLayer, int MDFT)
{
#define NUM_UL_SYMB_SF 14
#define NUM_LAYER 2
#define NUM_MDFT 75
// int NumLayer = lte_phy_params->N_rx_ant;
// int MDFT = lte_phy_params->N_dft_sz;
#pragma HLS ARRAY_PARTITION variable=pDecSeq cyclic factor=2 dim=1
int NumULSymbSF = LTE_PHY_N_SYMB_PER_SUBFR;
for(int nlayer=0;nlayer</*NumLayer*/NUM_LAYER;nlayer++)
{
for(int nsym=0;nsym</*NumULSymbSF*/NUM_UL_SYMB_SF-2;nsym++)
{
#pragma HLS LOOP_FLATTEN
int idx = nlayer*(MDFT*(NumULSymbSF-2))+nsym*MDFT;
float norm = (float)sqrt((float)MDFT);
dft(MDFT, pDataMatrix + idx * 2, pDecSeq + idx * 2, -1);
for(int m = 0; m < /*MDFT*/ NUM_MDFT; m++)
{
#pragma HLS PIPELINE II=4
#pragma HLS DEPENDENCE array inter false
pDecSeq[2 * (idx + m) + 0] = pDecSeq[2 * (idx + m) + 0] / norm;
pDecSeq[2 * (idx + m) + 1] = pDecSeq[2 * (idx + m) + 1] / norm;
}
}
}
}
static double verify_impulse(fftd_func *dft,
int n, int veclen,
COMPLEX *inA,
COMPLEX *inB,
COMPLEX *inC,
COMPLEX *outA,
COMPLEX *outB,
COMPLEX *outC,
COMPLEX *tmp,
int rounds)
{
int N = n * veclen;
COMPLEX impulse;
int i;
double e, maxerr = 0.0;
/* test 2: check that the unit impulse is transformed properly */
RE(impulse) = 1.0;
IM(impulse) = 0.0;
for (i = 0; i < N; ++i) {
/* impulse */
RE(inA[i]) = 0.0;
IM(inA[i]) = 0.0;
/* transform of the impulse */
outA[i] = impulse;
}
for (i = 0; i < veclen; ++i)
inA[i * n] = impulse;
/* a simple test first, to help with debugging: */
dft((double *)outB, (double *)inA);
e = acmp(outB, outA, N);
if(e > maxerr) maxerr = e;
for (i = 0; i < rounds; ++i) {
fill_random(inB, N);
asub(inC, inA, inB, N);
dft((double *)outB, (double *)inB);
dft((double *)outC, (double *)inC);
aadd(tmp, outB, outC, N);
e = acmp(tmp, outA, N);
if(e > maxerr) maxerr = e;
}
return maxerr;
}
int mul(int n1, int *x1, int n2, int *x2) {
n = std::max(n1, n2);
for (bn = 0; (1<<bn) < n; ++bn); ++bn;
n = 1 << bn;
for (int i=0; i<n; ++i) a[i] = b[i] = comp(0, 0);
for (int i=0; i<n1; ++i) a[i] = comp(x1[i], 0);
for (int i=0; i<n2; ++i) b[i] = comp(x2[i], 0);
dft(a, false); dft(b, false);
for (int i=0; i<n; ++i) {
tmp[i].x = a[i].x * b[i].x - a[i].y * b[i].y;
tmp[i].y = a[i].x * b[i].y + a[i].y * b[i].x;
}
dft(tmp, true);
for (int i=0; i<n; ++i) res[i] = (type)(tmp[i].x/n + 0.1);
for (--n; n && !res[n]; --n);
return n+1;
}
void Feature::calcFrequency()
{
// TODO: optimize this part
if (mAreaVec.size() < MAX_AREA_VEC_SIZE) {
frequency = -1;
return;
}
// limit n to integer power of 2 for simplicity
// in fact, you can use function 'getOptimalDFTSize' to pad the input array
assert((MAX_AREA_VEC_SIZE & (MAX_AREA_VEC_SIZE - 1)) == 0);
/*domon:::::debug
vector<double>::size_type size = mAreaVec.size();
for (int i = 0; i < size - 1; i++) {
mAreaVec[i] = 600;
}
for (int i = size - 1; i < size; i++) {
mAreaVec[i] = 600 + 10;
}*/
vector<double> spec(MAX_AREA_VEC_SIZE);
dft(mAreaVec, spec);
/*domon:::::debug
printAreaVec();
vector<double>::size_type dft_size = spec.size();
for (int i = 0; i < dft_size; i++) {
cout << spec[i];
if (i != dft_size - 1) {
cout << "; ";
} else {
cout << endl;
}
}
//domon:::::debug*/
double maxAmpl = 0;
int idx = 0;
for (int i = 1; i < MAX_AREA_VEC_SIZE; i += 2) {
double ampl = (i == MAX_AREA_VEC_SIZE - 1) ? spec[i] :
sqrt(spec[i] * spec[i] + spec[i + 1] * spec[i + 1]);
if (ampl > maxAmpl) {
maxAmpl = ampl;
idx = (i + 1) / 2;
}
}
/*
double fps = videoHandler->getVideoFPS();
frequency = fps / MAX_AREA_VEC_SIZE * maxAmpl; //idx;
*/
#ifdef DEBUG_OUTPUT
cout << "fps: " << fps << ", frequency: " << frequency << endl;
#endif
}
/*
in input image
kernel filter kernel
return output image
*/
Mat Dip3::frequencyConvolution(Mat& in, Mat& kernel){
Mat tempA = Mat::zeros(in.rows, in.cols, CV_32FC1);
Mat tempB = Mat::zeros(in.rows, in.cols, CV_32FC1);
for (int x = 0; x < kernel.rows; x++) for (int y = 0; y < kernel.cols; y++) {
tempB.at<float>(x, y) = kernel.at<float>(x, y);
}
tempB = circShift(tempB, -1, -1);
dft(in, tempA, 0);
dft(tempB, tempB, 0);
mulSpectrums(tempA, tempB, tempB, 0);
dft(tempB, tempA, DFT_INVERSE + DFT_SCALE);
return tempA;
}
// Fourier descriptor
int test_fourier_descriptor(vector_t *fd, point_list_t *plist)
{
int i, n;
vector_t *time, *fourier, *fd;
complex_t comp;
assert(fd);
assert(plist);
assert(vecter_get_length(fd) == point_list_get_count(plist));
time = cvector_new_and_copy_point_list(plist);
fourier = vector_new(vector_get_length(time), true);
//fd = vector_new(vector_get_length(time), true);
dft(fourier, time);
n = vector_get_length(time);
// filtering
/*
comp.real = comp.imag = 0.0;
for (i = n / 2 - 16; i < n / 2 + 16; i++) {
cvector_put_value(comp, i, fourier);
}
*/
/////////////////////// Normalization ////////////////////////////
vector_copy(fd, fourier);
// For translation invariance, 0 frequency must have a zero value
cvector_put_value(comp, 0, fd);
// For scale invariance,
// fourier descriptor must be divied by the absolute of 1 frequency component.
cvector_read_value(&comp, 1, fd);
val = complex_get_abs(&comp);
vector_divide_scalar(fd, val);
ivector_divide_scalar(fd, val);
// For rotating and changes in starting point
// remove all phase information and
// consider only absolute values of the descriptor element
//f = fopen("fourier_descriptor.txt", "a+");
//fprintf(f, "%s", fn);
for (i = 0; i < vector_get_length(fd); i++) {
cvector_read_value(&comp, i, fd);
val = complex_get_abs(&comp);
vector_put_value(val, i, fd);
ivector_put_value(0, i, fd);
//fprintf(f, ", %lf", val);
}
//fprintf(f, "\n");
//fclose(f);
///////////////////////////////////////////////////////////////////
// idft(time, fourier);
return n;
}
int fourier(double *jr, double *ji, int n, int iflag)
{
int i2;
if ((i2 = ilog2(n)) > 0) {
return fft(jr, ji, n, i2, iflag);
} else {
return dft(jr, ji, n, iflag);
}
}
/*fft算法，输入图像为8U（灰度图），输出为2*32F的图像（实部与虚部，未进行四角校正）*/
Mat mydft(Mat &src)
{
Mat src2;
src.convertTo(src2, CV_32F);
Mat planes[] = { Mat_<float>(src2), Mat::zeros(src2.size(), CV_32F) };
Mat complexI;
merge(planes, 2, complexI);
dft(complexI, complexI);
return complexI;
}
void DenseGaussKernel(float sigma, const Mat &x,const Mat &y, Mat &k){
Mat xf, yf;
dft(x, xf, DFT_COMPLEX_OUTPUT);
dft(y, yf, DFT_COMPLEX_OUTPUT);
double xx = norm(x);
xx = xx*xx;
double yy = norm(y);
yy = yy*yy;
Mat xyf;
mulSpectrums(xf, yf, xyf, 0, true);
Mat xy;
cv::idft(xyf, xy, cv::DFT_SCALE | cv::DFT_REAL_OUTPUT); // Applying IDFT
CircShift(xy, scale_size(x.size(),0.5));
double numelx1 = x.cols*x.rows;
//exp((-1 / (sigma*sigma)) * abs((xx + yy - 2 * xy) / numelx1), k); //thsi setting is fixed by version 2(KCF)
exp((-1 / (sigma*sigma)) * max(0,(xx + yy - 2 * xy) / numelx1), k);
}
Cmat *power_spectrum_apply(PowerSpectrum *self, Cmat *data) {
Cmat *ps = cmat_new(data->rows, self->n_uniq_fft_points);
int i,j;
for (i=0;i<data->rows;++i) {
Cmat * ffts = dft(data->data[i], data->cols, self->nfft);
for (j=0;j<self->n_uniq_fft_points;++j) {
ps->data[i][j] = pow(ffts->data[0][j],2) + pow(ffts->data[1][j],2);
}
cmat_free(ffts);
}
return ps;
}
/*fft-inv算法，输入图像为有实部和虚部的2*32F图像，输出为8U灰度图*/
Mat myinvdft(Mat &src)
{
dft(src, src, DFT_INVERSE);
Mat dst;
vector<Mat_<float>> planes;
split(src, planes);
magnitude(planes[0], planes[1], planes[0]);
src = planes[0];
normalize(src, src, 0, 255, CV_MINMAX);
src.convertTo(dst, CV_8U);
return dst;
}
void check_blink(){
max_input=0;
X=dft();
if(X>FThreshold){
if(max_input>86) big_blink=1; //see the max adc val corresssponding to saturation output of eog ckt
//if(X>400) big_blink=1;//big blink fourier value;same values for small and big blink
//if(counter_BigB>7) big_blink=1;//arbitrary counter
else
small_blink=1;
}
}
void fft(std::vector<int> a, std::vector<int> b, std::vector<int>& c) {
c.clear();
int t = a.size() + b.size();
int n = 1; while (n < t) n *= 2;
int *ta = new int[n], *tb = new int[n];
for (int i = 0; i < n; i++) {
ta[i] = (i >= a.size() ? 0 : a[i]);
tb[i] = (i >= b.size() ? 0 : b[i]);
}
dft(ta, n, 1), dft(tb, n, 1);
for (int i = 0; i < n; i++)
ta[i] = 1LL * ta[i] * tb[i] % P;
dft(ta, n, -1);
int rev = pwr(n, P-2, P);
for (int i = 0; i < n; i++) ta[i] = 1LL * ta[i] * rev % P;
c.resize(a.size()+b.size()-1);
for (int i = 0; i < a.size()+b.size()-1; i++)
c[i] = ta[i];
delete [] ta;
delete [] tb;
}
void dft(int n, std::complex<double>* buffer,
int offset, int step, std::complex<double>* epsilon)
{
if(n == 1) return;
int m = n >> 1;
dft(m, buffer, offset, step << 1, epsilon);
dft(m, buffer, offset + step, step << 1, epsilon);
for(int k = 0; k != m; ++k)
{
int pos = 2 * step * k;
temp[k] = buffer[pos + offset]
+ epsilon[k * step]
* buffer[pos + offset + step];
temp[k + m] = buffer[pos + offset]
- epsilon[k * step]
* buffer[pos + offset + step];
}
for(int i = 0; i != n; ++i)
buffer[i * step + offset] = temp[i];
}
int main()
{
V = fio, E = fio;
while (E--)
if ((u = fio) != (v = fio))
edg_ins(EA, u, v);
for (u = 1; u <= V; ++u)
f[u] = 1;
for (u = 1; u <= V; ++u)
if (!dfn[u]) dft(u);
printf(lld "\n", ans);
return 0;
}
