← Back to branch summary

~ubuntu-branches/ubuntu/raring/ffc/raring

« back to all changes in this revision

Viewing changes to test/regression/references/r_quadrature/SubDomains.h

  • Committer: Package Import Robot
  • Author(s): Johannes Ring
  • Date: 2011-10-26 17:52:20 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20111026175220-ope1dzqv4jn2b8pq
Tags: 1.0-beta2-1
* New upstream release. This release includes some performance
  improvements for evaluating basis functions. It also adds support
  for Bessel functions and error functions.
* debian/control: Bump version numbers for python-ufc, python-fiat,
  python-instant, and python-ufl.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/regression/references/r_quadrature/SubDomains.h
1
 
// This code conforms with the UFC specification version 2.0.0
2
 
// and was automatically generated by FFC version 0.9.10.
 
1
// This code conforms with the UFC specification version 2.0.2
 
2
// and was automatically generated by FFC version 1.0-beta+.
3
3
// 
4
4
// This code was generated with the following parameters:
5
5
// 
149
149
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
150
150
      
151
151
      // Declare helper variables.
152
 
      unsigned int rr = 0;
153
 
      unsigned int ss = 0;
154
152
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
155
153
      
156
154
      // Compute basisvalues.
157
155
      basisvalues[0] = 1.0;
158
156
      basisvalues[1] = tmp0;
159
 
      for (unsigned int r = 0; r < 1; r++)
160
 
      {
161
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
162
 
        ss = r*(r + 1)*(r + 2)/6;
163
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
164
 
      }// end loop over 'r'
165
 
      for (unsigned int r = 0; r < 1; r++)
166
 
      {
167
 
        for (unsigned int s = 0; s < 1 - r; s++)
168
 
        {
169
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
170
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
171
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
172
 
        }// end loop over 's'
173
 
      }// end loop over 'r'
174
 
      for (unsigned int r = 0; r < 2; r++)
175
 
      {
176
 
        for (unsigned int s = 0; s < 2 - r; s++)
177
 
        {
178
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
179
 
          {
180
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
181
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
182
 
          }// end loop over 't'
183
 
        }// end loop over 's'
184
 
      }// end loop over 'r'
 
157
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
158
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
159
      basisvalues[0] *= std::sqrt(0.75);
 
160
      basisvalues[3] *= std::sqrt(1.25);
 
161
      basisvalues[2] *= std::sqrt(2.5);
 
162
      basisvalues[1] *= std::sqrt(7.5);
185
163
      
186
164
      // Table(s) of coefficients.
187
165
      static const double coefficients0[4] = \
201
179
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
202
180
      
203
181
      // Declare helper variables.
204
 
      unsigned int rr = 0;
205
 
      unsigned int ss = 0;
206
182
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
207
183
      
208
184
      // Compute basisvalues.
209
185
      basisvalues[0] = 1.0;
210
186
      basisvalues[1] = tmp0;
211
 
      for (unsigned int r = 0; r < 1; r++)
212
 
      {
213
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
214
 
        ss = r*(r + 1)*(r + 2)/6;
215
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
216
 
      }// end loop over 'r'
217
 
      for (unsigned int r = 0; r < 1; r++)
218
 
      {
219
 
        for (unsigned int s = 0; s < 1 - r; s++)
220
 
        {
221
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
222
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
223
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
224
 
        }// end loop over 's'
225
 
      }// end loop over 'r'
226
 
      for (unsigned int r = 0; r < 2; r++)
227
 
      {
228
 
        for (unsigned int s = 0; s < 2 - r; s++)
229
 
        {
230
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
231
 
          {
232
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
233
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
234
 
          }// end loop over 't'
235
 
        }// end loop over 's'
236
 
      }// end loop over 'r'
 
187
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
188
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
189
      basisvalues[0] *= std::sqrt(0.75);
 
190
      basisvalues[3] *= std::sqrt(1.25);
 
191
      basisvalues[2] *= std::sqrt(2.5);
 
192
      basisvalues[1] *= std::sqrt(7.5);
237
193
      
238
194
      // Table(s) of coefficients.
239
195
      static const double coefficients0[4] = \
253
209
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
254
210
      
255
211
      // Declare helper variables.
256
 
      unsigned int rr = 0;
257
 
      unsigned int ss = 0;
258
212
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
259
213
      
260
214
      // Compute basisvalues.
261
215
      basisvalues[0] = 1.0;
262
216
      basisvalues[1] = tmp0;
263
 
      for (unsigned int r = 0; r < 1; r++)
264
 
      {
265
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
266
 
        ss = r*(r + 1)*(r + 2)/6;
267
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
268
 
      }// end loop over 'r'
269
 
      for (unsigned int r = 0; r < 1; r++)
270
 
      {
271
 
        for (unsigned int s = 0; s < 1 - r; s++)
272
 
        {
273
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
274
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
275
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
276
 
        }// end loop over 's'
277
 
      }// end loop over 'r'
278
 
      for (unsigned int r = 0; r < 2; r++)
279
 
      {
280
 
        for (unsigned int s = 0; s < 2 - r; s++)
281
 
        {
282
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
283
 
          {
284
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
285
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
286
 
          }// end loop over 't'
287
 
        }// end loop over 's'
288
 
      }// end loop over 'r'
 
217
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
218
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
219
      basisvalues[0] *= std::sqrt(0.75);
 
220
      basisvalues[3] *= std::sqrt(1.25);
 
221
      basisvalues[2] *= std::sqrt(2.5);
 
222
      basisvalues[1] *= std::sqrt(7.5);
289
223
      
290
224
      // Table(s) of coefficients.
291
225
      static const double coefficients0[4] = \
305
239
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
306
240
      
307
241
      // Declare helper variables.
308
 
      unsigned int rr = 0;
309
 
      unsigned int ss = 0;
310
242
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
311
243
      
312
244
      // Compute basisvalues.
313
245
      basisvalues[0] = 1.0;
314
246
      basisvalues[1] = tmp0;
315
 
      for (unsigned int r = 0; r < 1; r++)
316
 
      {
317
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
318
 
        ss = r*(r + 1)*(r + 2)/6;
319
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
320
 
      }// end loop over 'r'
321
 
      for (unsigned int r = 0; r < 1; r++)
322
 
      {
323
 
        for (unsigned int s = 0; s < 1 - r; s++)
324
 
        {
325
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
326
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
327
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
328
 
        }// end loop over 's'
329
 
      }// end loop over 'r'
330
 
      for (unsigned int r = 0; r < 2; r++)
331
 
      {
332
 
        for (unsigned int s = 0; s < 2 - r; s++)
333
 
        {
334
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
335
 
          {
336
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
337
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
338
 
          }// end loop over 't'
339
 
        }// end loop over 's'
340
 
      }// end loop over 'r'
 
247
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
248
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
249
      basisvalues[0] *= std::sqrt(0.75);
 
250
      basisvalues[3] *= std::sqrt(1.25);
 
251
      basisvalues[2] *= std::sqrt(2.5);
 
252
      basisvalues[1] *= std::sqrt(7.5);
341
253
      
342
254
      // Table(s) of coefficients.
343
255
      static const double coefficients0[4] = \
500
412
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
501
413
      
502
414
      // Declare helper variables.
503
 
      unsigned int rr = 0;
504
 
      unsigned int ss = 0;
505
415
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
506
416
      
507
417
      // Compute basisvalues.
508
418
      basisvalues[0] = 1.0;
509
419
      basisvalues[1] = tmp0;
510
 
      for (unsigned int r = 0; r < 1; r++)
511
 
      {
512
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
513
 
        ss = r*(r + 1)*(r + 2)/6;
514
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
515
 
      }// end loop over 'r'
516
 
      for (unsigned int r = 0; r < 1; r++)
517
 
      {
518
 
        for (unsigned int s = 0; s < 1 - r; s++)
519
 
        {
520
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
521
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
522
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
523
 
        }// end loop over 's'
524
 
      }// end loop over 'r'
525
 
      for (unsigned int r = 0; r < 2; r++)
526
 
      {
527
 
        for (unsigned int s = 0; s < 2 - r; s++)
528
 
        {
529
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
530
 
          {
531
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
532
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
533
 
          }// end loop over 't'
534
 
        }// end loop over 's'
535
 
      }// end loop over 'r'
 
420
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
421
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
422
      basisvalues[0] *= std::sqrt(0.75);
 
423
      basisvalues[3] *= std::sqrt(1.25);
 
424
      basisvalues[2] *= std::sqrt(2.5);
 
425
      basisvalues[1] *= std::sqrt(7.5);
536
426
      
537
427
      // Table(s) of coefficients.
538
428
      static const double coefficients0[4] = \
694
584
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
695
585
      
696
586
      // Declare helper variables.
697
 
      unsigned int rr = 0;
698
 
      unsigned int ss = 0;
699
587
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
700
588
      
701
589
      // Compute basisvalues.
702
590
      basisvalues[0] = 1.0;
703
591
      basisvalues[1] = tmp0;
704
 
      for (unsigned int r = 0; r < 1; r++)
705
 
      {
706
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
707
 
        ss = r*(r + 1)*(r + 2)/6;
708
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
709
 
      }// end loop over 'r'
710
 
      for (unsigned int r = 0; r < 1; r++)
711
 
      {
712
 
        for (unsigned int s = 0; s < 1 - r; s++)
713
 
        {
714
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
715
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
716
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
717
 
        }// end loop over 's'
718
 
      }// end loop over 'r'
719
 
      for (unsigned int r = 0; r < 2; r++)
720
 
      {
721
 
        for (unsigned int s = 0; s < 2 - r; s++)
722
 
        {
723
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
724
 
          {
725
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
726
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
727
 
          }// end loop over 't'
728
 
        }// end loop over 's'
729
 
      }// end loop over 'r'
 
592
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
593
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
594
      basisvalues[0] *= std::sqrt(0.75);
 
595
      basisvalues[3] *= std::sqrt(1.25);
 
596
      basisvalues[2] *= std::sqrt(2.5);
 
597
      basisvalues[1] *= std::sqrt(7.5);
730
598
      
731
599
      // Table(s) of coefficients.
732
600
      static const double coefficients0[4] = \
888
756
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
889
757
      
890
758
      // Declare helper variables.
891
 
      unsigned int rr = 0;
892
 
      unsigned int ss = 0;
893
759
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
894
760
      
895
761
      // Compute basisvalues.
896
762
      basisvalues[0] = 1.0;
897
763
      basisvalues[1] = tmp0;
898
 
      for (unsigned int r = 0; r < 1; r++)
899
 
      {
900
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
901
 
        ss = r*(r + 1)*(r + 2)/6;
902
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
903
 
      }// end loop over 'r'
904
 
      for (unsigned int r = 0; r < 1; r++)
905
 
      {
906
 
        for (unsigned int s = 0; s < 1 - r; s++)
907
 
        {
908
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
909
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
910
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
911
 
        }// end loop over 's'
912
 
      }// end loop over 'r'
913
 
      for (unsigned int r = 0; r < 2; r++)
914
 
      {
915
 
        for (unsigned int s = 0; s < 2 - r; s++)
916
 
        {
917
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
918
 
          {
919
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
920
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
921
 
          }// end loop over 't'
922
 
        }// end loop over 's'
923
 
      }// end loop over 'r'
 
764
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
765
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
766
      basisvalues[0] *= std::sqrt(0.75);
 
767
      basisvalues[3] *= std::sqrt(1.25);
 
768
      basisvalues[2] *= std::sqrt(2.5);
 
769
      basisvalues[1] *= std::sqrt(7.5);
924
770
      
925
771
      // Table(s) of coefficients.
926
772
      static const double coefficients0[4] = \
1082
928
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1083
929
      
1084
930
      // Declare helper variables.
1085
 
      unsigned int rr = 0;
1086
 
      unsigned int ss = 0;
1087
931
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1088
932
      
1089
933
      // Compute basisvalues.
1090
934
      basisvalues[0] = 1.0;
1091
935
      basisvalues[1] = tmp0;
1092
 
      for (unsigned int r = 0; r < 1; r++)
1093
 
      {
1094
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1095
 
        ss = r*(r + 1)*(r + 2)/6;
1096
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1097
 
      }// end loop over 'r'
1098
 
      for (unsigned int r = 0; r < 1; r++)
1099
 
      {
1100
 
        for (unsigned int s = 0; s < 1 - r; s++)
1101
 
        {
1102
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1103
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1104
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1105
 
        }// end loop over 's'
1106
 
      }// end loop over 'r'
1107
 
      for (unsigned int r = 0; r < 2; r++)
1108
 
      {
1109
 
        for (unsigned int s = 0; s < 2 - r; s++)
1110
 
        {
1111
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
1112
 
          {
1113
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1114
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1115
 
          }// end loop over 't'
1116
 
        }// end loop over 's'
1117
 
      }// end loop over 'r'
 
936
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
937
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
938
      basisvalues[0] *= std::sqrt(0.75);
 
939
      basisvalues[3] *= std::sqrt(1.25);
 
940
      basisvalues[2] *= std::sqrt(2.5);
 
941
      basisvalues[1] *= std::sqrt(7.5);
1118
942
      
1119
943
      // Table(s) of coefficients.
1120
944
      static const double coefficients0[4] = \