← Back to branch summary

~ubuntu-branches/ubuntu/trusty/scilab/trusty

« back to all changes in this revision

Viewing changes to modules/fftw/tests/unit_tests/fftw_part1.tst

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2012-08-02 11:02:49 UTC
  • mfrom: (1.4.6)
  • Revision ID: package-import@ubuntu.com-20120802110249-0v5953emkp25geuz
Tags: 5.4.0-beta-2-1~exp1
* New upstream release
* Remove libscilab-java (remove upstream). Use libscilab2-java instead.

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/fftw/tests/unit_tests/fftw_part1.tst
 
1
// =============================================================================
 
2
// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 
3
// Copyright (C) 2012 - INRIA - Serge STEER
 
4
//
 
5
//  This file is distributed under the same license as the Scilab package.
 
6
// =============================================================================
 
7
 
 
8
// <-- JVM NOT MANDATORY -->
 
9
 
 
10
//============================================================================================
 
11
//=================================fft(A [,isn [,flag]]) =====================================
 
12
//============================================================================================
 
13
 
 
14
//1-D transform ******************************************************************************
 
15
//R2C case ------------------------------------------------------------------------------------
 
16
assert_checkequal(fft(1:4),[10,-2+%i*2,-2,-2-%i*2]);
 
17
assert_checkequal(ifft(1:4),conj(fft(1:4)/4));
 
18
assert_checkequal(fft(1:4,-1),[10,-2+%i*2,-2,-2-%i*2]);
 
19
assert_checkequal(fft(1:4,1),conj(fft(1:4,-1)/4));
 
20
//C2R case ------------------------------------------------------------------------------------
 
21
//         ODD case
 
22
A=[1 0 %i -%i 0];
 
23
y=fft(A);
 
24
y_ref=[1, 2.17557050458494672, -0.902113032590307062, 2.90211303259030728, -0.17557050458494649];
 
25
assert_checktrue(isreal(y));
 
26
assert_checkalmostequal(y,y_ref);
 
27
assert_checkalmostequal(A,ifft(y));
 
28
 
 
29
y=fft(A,"symmetric");
 
30
assert_checktrue(isreal(y));
 
31
assert_checkalmostequal(y,y_ref);
 
32
 
 
33
y=fft(A,"nonsymmetric");
 
34
assert_checktrue(~isreal(y));
 
35
assert_checkalmostequal(y,y_ref);
 
36
 
 
37
 
 
38
y=fft(A,-1);
 
39
assert_checktrue(isreal(y));
 
40
assert_checkalmostequal(y,y_ref);
 
41
assert_checkalmostequal(A,fft(y,1));
 
42
 
 
43
//         EVEN case
 
44
A=[1 0 %i 2 -%i 0];
 
45
y=fft(A);
 
46
y_ref=[3, 0.73205080756887719, 1.2679491924311228,-1, 4.7320508075688767,-2.73205080756887719];
 
47
assert_checktrue(isreal(y));
 
48
assert_checkalmostequal(y,y_ref);
 
49
assert_checkalmostequal(A,ifft(y),0,10*%eps);
 
50
 
 
51
y=fft(A,"symmetric");
 
52
assert_checktrue(isreal(y));
 
53
assert_checkalmostequal(y,y_ref);
 
54
 
 
55
y=fft(A,"nonsymmetric");
 
56
assert_checktrue(~isreal(y));
 
57
assert_checkalmostequal(y,y_ref);
 
58
 
 
59
y=fft(A,-1);
 
60
assert_checktrue(isreal(y));
 
61
assert_checkalmostequal(y,y_ref);
 
62
assert_checkalmostequal(A,fft(y,1),10*%eps,10*%eps);
 
63
 
 
64
//R2R case ------------------------------------------------------------------------------------
 
65
//         ODD case
 
66
y=fft(1);
 
67
assert_checktrue(isreal(y));
 
68
assert_checkequal(y,1);
 
69
 
 
70
A=[0 1 2 2 1];
 
71
y=fft(A);
 
72
y_ref=[6,-2.61803398874989446, -0.381966011250104875, -0.381966011250104875, -2.61803398874989446];
 
73
assert_checktrue(isreal(y));
 
74
assert_checkalmostequal(y,y_ref);
 
75
assert_checkalmostequal(A,ifft(y),10*%eps,10*%eps);
 
76
 
 
77
y=fft(A,"symmetric");
 
78
assert_checktrue(isreal(y));
 
79
assert_checkalmostequal(y,y_ref);
 
80
 
 
81
y=fft(A,"nonsymmetric");
 
82
assert_checktrue(~isreal(y));
 
83
assert_checkalmostequal(y,y_ref);
 
84
 
 
85
//        EVEN case
 
86
A=1:2;
 
87
y=fft(A);
 
88
assert_checktrue(isreal(y));
 
89
assert_checkalmostequal(y,[3 -1]);
 
90
assert_checkalmostequal(A,ifft(y),10*%eps,10*%eps);
 
91
 
 
92
A=[0 1 2 5 2 1];
 
93
y=fft(A);
 
94
y_ref=[11,-6, 2,-3, 2,-6];
 
95
assert_checktrue(isreal(y));
 
96
assert_checkequal(y,y_ref);
 
97
assert_checkalmostequal(A,ifft(y),10*%eps,10*%eps);
 
98
y=fft(A,"symmetric");
 
99
assert_checktrue(isreal(y));
 
100
assert_checkalmostequal(y,y_ref);
 
101
 
 
102
y=fft(A,"nonsymmetric");
 
103
assert_checktrue(~isreal(y));
 
104
assert_checkalmostequal(y,y_ref);
 
105
 
 
106
 
 
107
//C2C case ------------------------------------------------------------------------------------
 
108
A=[1+%i 2 5*%i -8+5*%i];
 
109
y=fft(A);
 
110
y_ref=[-5+%i*11,-4-%i*14, 7+%i, 6+%i*6];
 
111
assert_checkalmostequal(y,y_ref);
 
112
assert_checkalmostequal(A,ifft(y));
 
113
 
 
114
//2-D transform  *******************************************************************************
 
115
 
 
116
//R2R case  ------------------------------------------------------------------------------------
 
117
//         ODD X EVEN case
 
118
A=[0   1   1
 
119
   2  -1  -1
 
120
   3   4   4
 
121
   2  -1  -1];
 
122
y=fft(A);
 
123
y_ref=[ 13, 4, 4;
 
124
        -9, 0, 0;
 
125
        13,-8,-8;
 
126
        -9, 0, 0];
 
127
 
 
128
assert_checktrue(isreal(y));
 
129
assert_checkalmostequal(y,y_ref);
 
130
assert_checkalmostequal(A,ifft(y),0,10*%eps);
 
131
 
 
132
y=fft(A,"symmetric");
 
133
assert_checktrue(isreal(y));
 
134
assert_checkalmostequal(y,y_ref);
 
135
 
 
136
y=fft(A,"nonsymmetric");
 
137
assert_checktrue(~isreal(y));
 
138
assert_checkalmostequal(y,y_ref);
 
139
 
 
140
 
 
141
 
 
142
//         EVEN X EVEN case
 
143
A=[0   1  5  1
 
144
   2  -1  6 -1
 
145
   3   4  7  4
 
146
   2  -1  6 -1];
 
147
y=fft(A);
 
148
y_ref=[37, -17, 25,-17;
 
149
       -11, -1,  1, -1;
 
150
        13, -1,-15, -1;
 
151
       -11, -1,  1, -1];
 
152
 
 
153
assert_checktrue(isreal(y));
 
154
assert_checkalmostequal(y,y_ref);
 
155
assert_checkalmostequal(A,ifft(y),0,10*%eps);
 
156
 
 
157
y=fft(A,"symmetric");
 
158
assert_checktrue(isreal(y));
 
159
assert_checkalmostequal(y,y_ref);
 
160
 
 
161
y=fft(A,"nonsymmetric");
 
162
assert_checktrue(~isreal(y));
 
163
assert_checkalmostequal(y,y_ref);
 
164
 
 
165
 
 
166
//         ODD X ODD case
 
167
A=[0  1  1
 
168
   2 -1 -1
 
169
   2 -1 -1];
 
170
y=fft(A);
 
171
y_ref=[ 2, 5, 5;
 
172
        2,-4,-4;
 
173
        2,-4,-4];
 
174
 
 
175
assert_checktrue(isreal(y));
 
176
assert_checkalmostequal(y,y_ref); 
 
177
assert_checkalmostequal(A,ifft(y),0,10*%eps);
 
178
 
 
179
A=[0   1  5  1
 
180
   2  -1  6 -1
 
181
   3   4  7  4
 
182
   2  -1  6 -1];
 
183
y=fft(A);
 
184
y_ref=[37, -17, 25,-17;
 
185
       -11, -1,  1, -1;
 
186
        13, -1,-15, -1;
 
187
       -11, -1,  1, -1];
 
188
 
 
189
assert_checktrue(isreal(y));
 
190
assert_checkalmostequal(y,y_ref);
 
191
assert_checkalmostequal(A,ifft(y),0,10*%eps);
 
192
 
 
193
y=fft(A,-1,"symmetric");
 
194
assert_checktrue(isreal(y));
 
195
assert_checkalmostequal(y,y_ref);
 
196
 
 
197
y=fft(A,-1,"nonsymmetric");
 
198
assert_checktrue(~isreal(y));
 
199
assert_checkalmostequal(y,y_ref);
 
200
 
 
201
 
 
202
A=[1 2 3 3 2;4 6 9 11 8;5 7 10 10 7;4 8 11 9 6];
 
203
y=fft(A);
 
204
y_ref=[ 126,-25.1803398874989490,-2.81966011250105097,-2.81966011250105097,-25.1803398874989490;
 
205
       -28, 10.391435051850296,-1.68915303351051138, 1.21701707851093177,-1.91929909685071642;
 
206
       -26, 6.2360679774997898, 1.76393202250021019, 1.76393202250021019, 6.2360679774997898;
 
207
       -28,-1.91929909685071642, 1.21701707851093177,-1.68915303351051138, 10.391435051850296];
 
208
assert_checktrue(isreal(y));
 
209
assert_checkalmostequal(y,y_ref); 
 
210
assert_checkalmostequal(A,ifft(y));
 
211
 
 
212
y=fft(A,-1,"symmetric");
 
213
assert_checktrue(isreal(y));
 
214
assert_checkalmostequal(y,y_ref);
 
215
 
 
216
y=fft(A,-1,"nonsymmetric");
 
217
assert_checktrue(~isreal(y));
 
218
assert_checkalmostequal(y,y_ref);
 
219
 
 
220
 
 
221
//R2C case ------------------------------------------------------------------------------------
 
222
A=[1 2 3;7 3 9;-1 5 4;0 8 -3];
 
223
y=fft(A);
 
224
y_ref=[38,     -8.5-%i*4.33012701892219276,                -8.5+%i*4.33012701892219276;
 
225
      -2-%i*14, 18.722431864335455-%i*1.76794919243112281  -10.7224318643354568-%i*5.23205080756887675;               
 
226
      -10,     -5.5+%i*4.33012701892219276,                -5.5-%i*4.33012701892219276;
 
227
      -2+%i*14,-10.7224318643354568+%i*5.23205080756887675, 18.722431864335455+%i*1.76794919243112281];    
 
228
assert_checkalmostequal(y,y_ref);
 
229
assert_checkalmostequal(A,ifft(y),0,10*%eps);
 
230
 
 
231
y=fft(A,1);
 
232
y_ref=[3.16666666666666607,                       -0.70833333333333326+%i*0.36084391824351614,-0.70833333333333326-%i*0.36084391824351614;
 
233
      -0.16666666666666660+%i*1.16666666666666652, 1.56020265536128777+%i*0.14732909936926014,-0.89353598869462125+%i*0.43600423396407301;
 
234
      -0.83333333333333337,                       -0.45833333333333320-%i*0.36084391824351603,-0.45833333333333320+%i*0.36084391824351603;
 
235
      -0.16666666666666660-%i*1.16666666666666652,-0.89353598869462125-%i*0.43600423396407301,1.56020265536128777-%i*0.14732909936926014];
 
236
assert_checkalmostequal(y,y_ref);
 
237
//C2R case
 
238
//------------------------------------------------------------------------------------
 
239
//         ODD X EVEN case
 
240
A=[0     %i  -%i
 
241
   2+%i  -1  -1
 
242
   3      4   4
 
243
   2-%i  -1  -1];
 
244
y=fft(A);
 
245
y_ref=[ 11, 6.7320508075688767,   3.2679491924311228;
 
246
        -9, 4.7320508075688767,   1.2679491924311228;
 
247
        11,-5.26794919243112325, -8.7320508075688767;
 
248
       -13, 0.73205080756887719, -2.73205080756887719];
 
249
assert_checktrue(isreal(y));
 
250
assert_checkalmostequal(y,y_ref);  
 
251
assert_checkalmostequal(A,ifft(y),0,10*%eps);
 
252
A=[1 2 3 3 2;4 6 9 11 8;5 7 10 10 7;4 8 11 9 6];
 
253
y=fft(A);
 
254
y_ref=[ 126,-25.1803398874989490,-2.81966011250105097,-2.81966011250105097,-25.1803398874989490;
 
255
       -28, 10.391435051850296,-1.68915303351051138, 1.21701707851093177,-1.91929909685071642;
 
256
       -26, 6.2360679774997898, 1.76393202250021019, 1.76393202250021019, 6.2360679774997898;
 
257
       -28,-1.91929909685071642, 1.21701707851093177,-1.68915303351051138, 10.391435051850296];
 
258
assert_checktrue(isreal(y));
 
259
assert_checkalmostequal(y,y_ref); 
 
260
assert_checkalmostequal(A,ifft(y));
 
261
 
 
262
y=fft(A,-1,"symmetric");
 
263
assert_checktrue(isreal(y));
 
264
assert_checkalmostequal(y,y_ref);
 
265
 
 
266
y=fft(A,-1,"nonsymmetric");
 
267
assert_checktrue(~isreal(y));
 
268
assert_checkalmostequal(y,y_ref);
 
269
 
 
270
 
 
271
//         ODD X ODD case
 
272
A=[0     %i  -%i
 
273
   2+%i  -1  -1
 
274
   2-%i  -1  -1];
 
275
y=fft(A);
 
276
y_ref=[0,                    7.7320508075688767,   4.26794919243112325;
 
277
       1.73205080756887719,  0.46410161513775439, -3;
 
278
       -1.73205080756887719,-2.99999999999999956, -6.46410161513775350];
 
279
 
 
280
assert_checktrue(isreal(y));
 
281
assert_checkalmostequal(y,y_ref);  
 
282
assert_checkalmostequal(A,ifft(y),0,10*%eps);
 
283
 
 
284
y=fft(A,-1,"symmetric");
 
285
assert_checktrue(isreal(y));
 
286
assert_checkalmostequal(y,y_ref);
 
287
 
 
288
y=fft(A,-1,"nonsymmetric");
 
289
assert_checktrue(~isreal(y));
 
290
assert_checkalmostequal(y,y_ref);
 
291
 
 
292
 
 
293
A=[1440, 32-%i*28,-102-%i*188,-102+%i*188, 32+%i*28;
 
294
   140-%i*52,-21+%i*14,-33+%i*8, 31+%i*77, 8+%i*169;
 
295
   30,-179+%i*40,-32-%i*175, 97-%i*107,-191-%i*147;
 
296
   20,-83-%i*162,-127+%i*71,-127-%i*71,-83+%i*162;
 
297
   30,-191+%i*147, 97+%i*107,-32+%i*175,-179-%i*40;
 
298
   140+%i*52, 8-%i*169, 31-%i*77,-33-%i*8,-21-%i*14];
 
299
y=fft(A);
 
300
y_ref=[ 600, 1201.23812370118321, 2697.02967953848838, 2102.2365384314553, 2399.49565832887311;
 
301
        1800.35521029058418, 1800.85854102712074, 897.335302928384408, 598.365730980120588,2102.75200480588182;
 
302
        2097.89073857917083, 901.733860383104911, 600.566385143489583, 602.768240434540644,1796.70756549178577;
 
303
        900, 1503.68526108760511, 2698.74007483319838, 598.106629651731282, 299.468034427465;
 
304
        2.10926142082939805, 1797.22849022236483, 902.940272151356453, 1500.39858431578159,2697.65660185757633;
 
305
        2399.64478970941582, 898.55653188654594, 2102.57661444176256, 601.137293239859559,2098.41798069032438];
 
306
assert_checktrue(isreal(y));
 
307
assert_checkalmostequal(y,y_ref);  
 
308
assert_checkalmostequal(A,ifft(y),0,1000*%eps);
 
309
 
 
310
 
 
311
y=fft(A,-1,"symmetric");
 
312
assert_checktrue(isreal(y));
 
313
assert_checkalmostequal(y,y_ref);
 
314
 
 
315
y=fft(A,-1,"nonsymmetric");
 
316
assert_checktrue(~isreal(y));
 
317
assert_checkalmostequal(y,y_ref);
 
318
 
 
319
 
 
320
//C2C case ------------------------------------------------------------------------------------
 
321
A=[0      %i  3-%i
 
322
   2+%i   -1  -1
 
323
   3       4   4
 
324
   2-3*%i -1  -1];
 
325
y=fft(A);
 
326
y_ref=[14-%i*2, 5.23205080756887675+%i*0.59807621135331601,1.76794919243112281-%i*4.598076211353316;
 
327
       -4,      5.23205080756887675+%i*2.598076211353316,  1.76794919243112281-%i*2.598076211353316;
 
328
       14+%i*2,-6.7679491924311233+%i*4.598076211353316,  -10.2320508075688767-%i*0.59807621135331601;
 
329
       -12,    -2.76794919243112281+%i*2.598076211353316,  -6.23205080756887675-%i*2.598076211353316];
 
330
assert_checkalmostequal(y,y_ref);  
 
331
assert_checkalmostequal(A,ifft(y),0,10*%eps);
 
332
 
 
333