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

« back to all changes in this revision

Viewing changes to test/regression/references/r_auto/VectorLaplaceGradCurl.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:
1
 
// This code conforms with the UFC specification version 2.0.0
2
 
// and was automatically generated by FFC version 1.0-beta.
 
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[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 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
 
      unsigned int tt = 0;
155
 
      double tmp5 = 0.0;
156
 
      double tmp6 = 0.0;
157
 
      double tmp7 = 0.0;
158
152
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
159
153
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
160
154
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
164
158
      // Compute basisvalues.
165
159
      basisvalues[0] = 1.0;
166
160
      basisvalues[1] = tmp0;
167
 
      for (unsigned int r = 1; r < 2; r++)
168
 
      {
169
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
170
 
        ss = r*(r + 1)*(r + 2)/6;
171
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
172
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
173
 
      }// end loop over 'r'
174
 
      for (unsigned int r = 0; r < 2; r++)
175
 
      {
176
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
177
 
        ss = r*(r + 1)*(r + 2)/6;
178
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
179
 
      }// end loop over 'r'
180
 
      for (unsigned int r = 0; r < 1; r++)
181
 
      {
182
 
        for (unsigned int s = 1; s < 2 - r; s++)
183
 
        {
184
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
185
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
186
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
187
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
188
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
189
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
190
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
191
 
        }// end loop over 's'
192
 
      }// end loop over 'r'
193
 
      for (unsigned int r = 0; r < 2; r++)
194
 
      {
195
 
        for (unsigned int s = 0; s < 2 - r; s++)
196
 
        {
197
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
198
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
199
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
200
 
        }// end loop over 's'
201
 
      }// end loop over 'r'
202
 
      for (unsigned int r = 0; r < 1; r++)
203
 
      {
204
 
        for (unsigned int s = 0; s < 1 - r; s++)
205
 
        {
206
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
207
 
          {
208
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
209
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
210
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
211
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
212
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
213
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
214
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
215
 
          }// end loop over 't'
216
 
        }// end loop over 's'
217
 
      }// end loop over 'r'
218
 
      for (unsigned int r = 0; r < 3; r++)
219
 
      {
220
 
        for (unsigned int s = 0; s < 3 - r; s++)
221
 
        {
222
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
223
 
          {
224
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
225
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
226
 
          }// end loop over 't'
227
 
        }// end loop over 's'
228
 
      }// end loop over 'r'
 
161
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
162
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
163
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
164
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
165
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
166
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
167
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
168
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
169
      basisvalues[0] *= std::sqrt(0.75);
 
170
      basisvalues[3] *= std::sqrt(1.25);
 
171
      basisvalues[9] *= std::sqrt(1.75);
 
172
      basisvalues[2] *= std::sqrt(2.5);
 
173
      basisvalues[8] *= std::sqrt(3.5);
 
174
      basisvalues[7] *= std::sqrt(5.25);
 
175
      basisvalues[1] *= std::sqrt(7.5);
 
176
      basisvalues[6] *= std::sqrt(10.5);
 
177
      basisvalues[5] *= std::sqrt(15.75);
 
178
      basisvalues[4] *= std::sqrt(26.25);
229
179
      
230
180
      // Table(s) of coefficients.
231
181
      static const double coefficients0[10] = \
245
195
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
246
196
      
247
197
      // Declare helper variables.
248
 
      unsigned int rr = 0;
249
 
      unsigned int ss = 0;
250
 
      unsigned int tt = 0;
251
 
      double tmp5 = 0.0;
252
 
      double tmp6 = 0.0;
253
 
      double tmp7 = 0.0;
254
198
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
255
199
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
256
200
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
260
204
      // Compute basisvalues.
261
205
      basisvalues[0] = 1.0;
262
206
      basisvalues[1] = tmp0;
263
 
      for (unsigned int r = 1; r < 2; r++)
264
 
      {
265
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
266
 
        ss = r*(r + 1)*(r + 2)/6;
267
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
268
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
269
 
      }// end loop over 'r'
270
 
      for (unsigned int r = 0; r < 2; r++)
271
 
      {
272
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
273
 
        ss = r*(r + 1)*(r + 2)/6;
274
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
275
 
      }// end loop over 'r'
276
 
      for (unsigned int r = 0; r < 1; r++)
277
 
      {
278
 
        for (unsigned int s = 1; s < 2 - r; s++)
279
 
        {
280
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
281
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
282
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
283
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
284
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
285
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
286
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
287
 
        }// end loop over 's'
288
 
      }// end loop over 'r'
289
 
      for (unsigned int r = 0; r < 2; r++)
290
 
      {
291
 
        for (unsigned int s = 0; s < 2 - r; s++)
292
 
        {
293
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
294
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
295
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
296
 
        }// end loop over 's'
297
 
      }// end loop over 'r'
298
 
      for (unsigned int r = 0; r < 1; r++)
299
 
      {
300
 
        for (unsigned int s = 0; s < 1 - r; s++)
301
 
        {
302
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
303
 
          {
304
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
305
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
306
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
307
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
308
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
309
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
310
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
311
 
          }// end loop over 't'
312
 
        }// end loop over 's'
313
 
      }// end loop over 'r'
314
 
      for (unsigned int r = 0; r < 3; r++)
315
 
      {
316
 
        for (unsigned int s = 0; s < 3 - r; s++)
317
 
        {
318
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
319
 
          {
320
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
321
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
322
 
          }// end loop over 't'
323
 
        }// end loop over 's'
324
 
      }// end loop over 'r'
 
207
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
208
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
209
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
210
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
211
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
212
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
213
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
214
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
215
      basisvalues[0] *= std::sqrt(0.75);
 
216
      basisvalues[3] *= std::sqrt(1.25);
 
217
      basisvalues[9] *= std::sqrt(1.75);
 
218
      basisvalues[2] *= std::sqrt(2.5);
 
219
      basisvalues[8] *= std::sqrt(3.5);
 
220
      basisvalues[7] *= std::sqrt(5.25);
 
221
      basisvalues[1] *= std::sqrt(7.5);
 
222
      basisvalues[6] *= std::sqrt(10.5);
 
223
      basisvalues[5] *= std::sqrt(15.75);
 
224
      basisvalues[4] *= std::sqrt(26.25);
325
225
      
326
226
      // Table(s) of coefficients.
327
227
      static const double coefficients0[10] = \
341
241
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
342
242
      
343
243
      // Declare helper variables.
344
 
      unsigned int rr = 0;
345
 
      unsigned int ss = 0;
346
 
      unsigned int tt = 0;
347
 
      double tmp5 = 0.0;
348
 
      double tmp6 = 0.0;
349
 
      double tmp7 = 0.0;
350
244
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
351
245
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
352
246
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
356
250
      // Compute basisvalues.
357
251
      basisvalues[0] = 1.0;
358
252
      basisvalues[1] = tmp0;
359
 
      for (unsigned int r = 1; r < 2; r++)
360
 
      {
361
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
362
 
        ss = r*(r + 1)*(r + 2)/6;
363
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
364
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
365
 
      }// end loop over 'r'
366
 
      for (unsigned int r = 0; r < 2; r++)
367
 
      {
368
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
369
 
        ss = r*(r + 1)*(r + 2)/6;
370
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
371
 
      }// end loop over 'r'
372
 
      for (unsigned int r = 0; r < 1; r++)
373
 
      {
374
 
        for (unsigned int s = 1; s < 2 - r; s++)
375
 
        {
376
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
377
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
378
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
379
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
380
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
381
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
382
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
383
 
        }// end loop over 's'
384
 
      }// end loop over 'r'
385
 
      for (unsigned int r = 0; r < 2; r++)
386
 
      {
387
 
        for (unsigned int s = 0; s < 2 - r; s++)
388
 
        {
389
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
390
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
391
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
392
 
        }// end loop over 's'
393
 
      }// end loop over 'r'
394
 
      for (unsigned int r = 0; r < 1; r++)
395
 
      {
396
 
        for (unsigned int s = 0; s < 1 - r; s++)
397
 
        {
398
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
399
 
          {
400
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
401
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
402
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
403
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
404
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
405
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
406
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
407
 
          }// end loop over 't'
408
 
        }// end loop over 's'
409
 
      }// end loop over 'r'
410
 
      for (unsigned int r = 0; r < 3; r++)
411
 
      {
412
 
        for (unsigned int s = 0; s < 3 - r; s++)
413
 
        {
414
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
415
 
          {
416
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
417
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
418
 
          }// end loop over 't'
419
 
        }// end loop over 's'
420
 
      }// end loop over 'r'
 
253
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
254
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
255
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
256
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
257
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
258
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
259
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
260
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
261
      basisvalues[0] *= std::sqrt(0.75);
 
262
      basisvalues[3] *= std::sqrt(1.25);
 
263
      basisvalues[9] *= std::sqrt(1.75);
 
264
      basisvalues[2] *= std::sqrt(2.5);
 
265
      basisvalues[8] *= std::sqrt(3.5);
 
266
      basisvalues[7] *= std::sqrt(5.25);
 
267
      basisvalues[1] *= std::sqrt(7.5);
 
268
      basisvalues[6] *= std::sqrt(10.5);
 
269
      basisvalues[5] *= std::sqrt(15.75);
 
270
      basisvalues[4] *= std::sqrt(26.25);
421
271
      
422
272
      // Table(s) of coefficients.
423
273
      static const double coefficients0[10] = \
437
287
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
438
288
      
439
289
      // Declare helper variables.
440
 
      unsigned int rr = 0;
441
 
      unsigned int ss = 0;
442
 
      unsigned int tt = 0;
443
 
      double tmp5 = 0.0;
444
 
      double tmp6 = 0.0;
445
 
      double tmp7 = 0.0;
446
290
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
447
291
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
448
292
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
452
296
      // Compute basisvalues.
453
297
      basisvalues[0] = 1.0;
454
298
      basisvalues[1] = tmp0;
455
 
      for (unsigned int r = 1; r < 2; r++)
456
 
      {
457
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
458
 
        ss = r*(r + 1)*(r + 2)/6;
459
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
460
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
461
 
      }// end loop over 'r'
462
 
      for (unsigned int r = 0; r < 2; r++)
463
 
      {
464
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
465
 
        ss = r*(r + 1)*(r + 2)/6;
466
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
467
 
      }// end loop over 'r'
468
 
      for (unsigned int r = 0; r < 1; r++)
469
 
      {
470
 
        for (unsigned int s = 1; s < 2 - r; s++)
471
 
        {
472
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
473
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
474
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
475
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
476
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
477
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
478
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
479
 
        }// end loop over 's'
480
 
      }// end loop over 'r'
481
 
      for (unsigned int r = 0; r < 2; r++)
482
 
      {
483
 
        for (unsigned int s = 0; s < 2 - r; s++)
484
 
        {
485
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
486
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
487
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
488
 
        }// end loop over 's'
489
 
      }// end loop over 'r'
490
 
      for (unsigned int r = 0; r < 1; r++)
491
 
      {
492
 
        for (unsigned int s = 0; s < 1 - r; s++)
493
 
        {
494
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
495
 
          {
496
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
497
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
498
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
499
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
500
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
501
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
502
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
503
 
          }// end loop over 't'
504
 
        }// end loop over 's'
505
 
      }// end loop over 'r'
506
 
      for (unsigned int r = 0; r < 3; r++)
507
 
      {
508
 
        for (unsigned int s = 0; s < 3 - r; s++)
509
 
        {
510
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
511
 
          {
512
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
513
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
514
 
          }// end loop over 't'
515
 
        }// end loop over 's'
516
 
      }// end loop over 'r'
 
299
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
300
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
301
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
302
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
303
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
304
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
305
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
306
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
307
      basisvalues[0] *= std::sqrt(0.75);
 
308
      basisvalues[3] *= std::sqrt(1.25);
 
309
      basisvalues[9] *= std::sqrt(1.75);
 
310
      basisvalues[2] *= std::sqrt(2.5);
 
311
      basisvalues[8] *= std::sqrt(3.5);
 
312
      basisvalues[7] *= std::sqrt(5.25);
 
313
      basisvalues[1] *= std::sqrt(7.5);
 
314
      basisvalues[6] *= std::sqrt(10.5);
 
315
      basisvalues[5] *= std::sqrt(15.75);
 
316
      basisvalues[4] *= std::sqrt(26.25);
517
317
      
518
318
      // Table(s) of coefficients.
519
319
      static const double coefficients0[10] = \
533
333
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
534
334
      
535
335
      // Declare helper variables.
536
 
      unsigned int rr = 0;
537
 
      unsigned int ss = 0;
538
 
      unsigned int tt = 0;
539
 
      double tmp5 = 0.0;
540
 
      double tmp6 = 0.0;
541
 
      double tmp7 = 0.0;
542
336
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
543
337
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
544
338
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
548
342
      // Compute basisvalues.
549
343
      basisvalues[0] = 1.0;
550
344
      basisvalues[1] = tmp0;
551
 
      for (unsigned int r = 1; r < 2; r++)
552
 
      {
553
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
554
 
        ss = r*(r + 1)*(r + 2)/6;
555
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
556
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
557
 
      }// end loop over 'r'
558
 
      for (unsigned int r = 0; r < 2; r++)
559
 
      {
560
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
561
 
        ss = r*(r + 1)*(r + 2)/6;
562
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
563
 
      }// end loop over 'r'
564
 
      for (unsigned int r = 0; r < 1; r++)
565
 
      {
566
 
        for (unsigned int s = 1; s < 2 - r; s++)
567
 
        {
568
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
569
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
570
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
571
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
572
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
573
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
574
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
575
 
        }// end loop over 's'
576
 
      }// end loop over 'r'
577
 
      for (unsigned int r = 0; r < 2; r++)
578
 
      {
579
 
        for (unsigned int s = 0; s < 2 - r; s++)
580
 
        {
581
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
582
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
583
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
584
 
        }// end loop over 's'
585
 
      }// end loop over 'r'
586
 
      for (unsigned int r = 0; r < 1; r++)
587
 
      {
588
 
        for (unsigned int s = 0; s < 1 - r; s++)
589
 
        {
590
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
591
 
          {
592
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
593
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
594
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
595
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
596
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
597
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
598
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
599
 
          }// end loop over 't'
600
 
        }// end loop over 's'
601
 
      }// end loop over 'r'
602
 
      for (unsigned int r = 0; r < 3; r++)
603
 
      {
604
 
        for (unsigned int s = 0; s < 3 - r; s++)
605
 
        {
606
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
607
 
          {
608
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
609
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
610
 
          }// end loop over 't'
611
 
        }// end loop over 's'
612
 
      }// end loop over 'r'
 
345
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
346
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
347
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
348
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
349
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
350
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
351
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
352
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
353
      basisvalues[0] *= std::sqrt(0.75);
 
354
      basisvalues[3] *= std::sqrt(1.25);
 
355
      basisvalues[9] *= std::sqrt(1.75);
 
356
      basisvalues[2] *= std::sqrt(2.5);
 
357
      basisvalues[8] *= std::sqrt(3.5);
 
358
      basisvalues[7] *= std::sqrt(5.25);
 
359
      basisvalues[1] *= std::sqrt(7.5);
 
360
      basisvalues[6] *= std::sqrt(10.5);
 
361
      basisvalues[5] *= std::sqrt(15.75);
 
362
      basisvalues[4] *= std::sqrt(26.25);
613
363
      
614
364
      // Table(s) of coefficients.
615
365
      static const double coefficients0[10] = \
629
379
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
630
380
      
631
381
      // Declare helper variables.
632
 
      unsigned int rr = 0;
633
 
      unsigned int ss = 0;
634
 
      unsigned int tt = 0;
635
 
      double tmp5 = 0.0;
636
 
      double tmp6 = 0.0;
637
 
      double tmp7 = 0.0;
638
382
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
639
383
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
640
384
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
644
388
      // Compute basisvalues.
645
389
      basisvalues[0] = 1.0;
646
390
      basisvalues[1] = tmp0;
647
 
      for (unsigned int r = 1; r < 2; r++)
648
 
      {
649
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
650
 
        ss = r*(r + 1)*(r + 2)/6;
651
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
652
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
653
 
      }// end loop over 'r'
654
 
      for (unsigned int r = 0; r < 2; r++)
655
 
      {
656
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
657
 
        ss = r*(r + 1)*(r + 2)/6;
658
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
659
 
      }// end loop over 'r'
660
 
      for (unsigned int r = 0; r < 1; r++)
661
 
      {
662
 
        for (unsigned int s = 1; s < 2 - r; s++)
663
 
        {
664
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
665
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
666
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
667
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
668
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
669
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
670
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
671
 
        }// end loop over 's'
672
 
      }// end loop over 'r'
673
 
      for (unsigned int r = 0; r < 2; r++)
674
 
      {
675
 
        for (unsigned int s = 0; s < 2 - r; s++)
676
 
        {
677
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
678
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
679
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
680
 
        }// end loop over 's'
681
 
      }// end loop over 'r'
682
 
      for (unsigned int r = 0; r < 1; r++)
683
 
      {
684
 
        for (unsigned int s = 0; s < 1 - r; s++)
685
 
        {
686
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
687
 
          {
688
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
689
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
690
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
691
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
692
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
693
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
694
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
695
 
          }// end loop over 't'
696
 
        }// end loop over 's'
697
 
      }// end loop over 'r'
698
 
      for (unsigned int r = 0; r < 3; r++)
699
 
      {
700
 
        for (unsigned int s = 0; s < 3 - r; s++)
701
 
        {
702
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
703
 
          {
704
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
705
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
706
 
          }// end loop over 't'
707
 
        }// end loop over 's'
708
 
      }// end loop over 'r'
 
391
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
392
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
393
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
394
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
395
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
396
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
397
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
398
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
399
      basisvalues[0] *= std::sqrt(0.75);
 
400
      basisvalues[3] *= std::sqrt(1.25);
 
401
      basisvalues[9] *= std::sqrt(1.75);
 
402
      basisvalues[2] *= std::sqrt(2.5);
 
403
      basisvalues[8] *= std::sqrt(3.5);
 
404
      basisvalues[7] *= std::sqrt(5.25);
 
405
      basisvalues[1] *= std::sqrt(7.5);
 
406
      basisvalues[6] *= std::sqrt(10.5);
 
407
      basisvalues[5] *= std::sqrt(15.75);
 
408
      basisvalues[4] *= std::sqrt(26.25);
709
409
      
710
410
      // Table(s) of coefficients.
711
411
      static const double coefficients0[10] = \
725
425
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
726
426
      
727
427
      // Declare helper variables.
728
 
      unsigned int rr = 0;
729
 
      unsigned int ss = 0;
730
 
      unsigned int tt = 0;
731
 
      double tmp5 = 0.0;
732
 
      double tmp6 = 0.0;
733
 
      double tmp7 = 0.0;
734
428
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
735
429
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
736
430
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
740
434
      // Compute basisvalues.
741
435
      basisvalues[0] = 1.0;
742
436
      basisvalues[1] = tmp0;
743
 
      for (unsigned int r = 1; r < 2; r++)
744
 
      {
745
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
746
 
        ss = r*(r + 1)*(r + 2)/6;
747
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
748
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
749
 
      }// end loop over 'r'
750
 
      for (unsigned int r = 0; r < 2; r++)
751
 
      {
752
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
753
 
        ss = r*(r + 1)*(r + 2)/6;
754
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
755
 
      }// end loop over 'r'
756
 
      for (unsigned int r = 0; r < 1; r++)
757
 
      {
758
 
        for (unsigned int s = 1; s < 2 - r; s++)
759
 
        {
760
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
761
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
762
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
763
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
764
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
765
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
766
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
767
 
        }// end loop over 's'
768
 
      }// end loop over 'r'
769
 
      for (unsigned int r = 0; r < 2; r++)
770
 
      {
771
 
        for (unsigned int s = 0; s < 2 - r; s++)
772
 
        {
773
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
774
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
775
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
776
 
        }// end loop over 's'
777
 
      }// end loop over 'r'
778
 
      for (unsigned int r = 0; r < 1; r++)
779
 
      {
780
 
        for (unsigned int s = 0; s < 1 - r; s++)
781
 
        {
782
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
783
 
          {
784
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
785
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
786
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
787
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
788
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
789
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
790
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
791
 
          }// end loop over 't'
792
 
        }// end loop over 's'
793
 
      }// end loop over 'r'
794
 
      for (unsigned int r = 0; r < 3; r++)
795
 
      {
796
 
        for (unsigned int s = 0; s < 3 - r; s++)
797
 
        {
798
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
799
 
          {
800
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
801
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
802
 
          }// end loop over 't'
803
 
        }// end loop over 's'
804
 
      }// end loop over 'r'
 
437
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
438
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
439
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
440
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
441
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
442
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
443
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
444
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
445
      basisvalues[0] *= std::sqrt(0.75);
 
446
      basisvalues[3] *= std::sqrt(1.25);
 
447
      basisvalues[9] *= std::sqrt(1.75);
 
448
      basisvalues[2] *= std::sqrt(2.5);
 
449
      basisvalues[8] *= std::sqrt(3.5);
 
450
      basisvalues[7] *= std::sqrt(5.25);
 
451
      basisvalues[1] *= std::sqrt(7.5);
 
452
      basisvalues[6] *= std::sqrt(10.5);
 
453
      basisvalues[5] *= std::sqrt(15.75);
 
454
      basisvalues[4] *= std::sqrt(26.25);
805
455
      
806
456
      // Table(s) of coefficients.
807
457
      static const double coefficients0[10] = \
821
471
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
822
472
      
823
473
      // Declare helper variables.
824
 
      unsigned int rr = 0;
825
 
      unsigned int ss = 0;
826
 
      unsigned int tt = 0;
827
 
      double tmp5 = 0.0;
828
 
      double tmp6 = 0.0;
829
 
      double tmp7 = 0.0;
830
474
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
831
475
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
832
476
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
836
480
      // Compute basisvalues.
837
481
      basisvalues[0] = 1.0;
838
482
      basisvalues[1] = tmp0;
839
 
      for (unsigned int r = 1; r < 2; r++)
840
 
      {
841
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
842
 
        ss = r*(r + 1)*(r + 2)/6;
843
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
844
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
845
 
      }// end loop over 'r'
846
 
      for (unsigned int r = 0; r < 2; r++)
847
 
      {
848
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
849
 
        ss = r*(r + 1)*(r + 2)/6;
850
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
851
 
      }// end loop over 'r'
852
 
      for (unsigned int r = 0; r < 1; r++)
853
 
      {
854
 
        for (unsigned int s = 1; s < 2 - r; s++)
855
 
        {
856
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
857
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
858
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
859
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
860
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
861
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
862
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
863
 
        }// end loop over 's'
864
 
      }// end loop over 'r'
865
 
      for (unsigned int r = 0; r < 2; r++)
866
 
      {
867
 
        for (unsigned int s = 0; s < 2 - r; s++)
868
 
        {
869
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
870
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
871
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
872
 
        }// end loop over 's'
873
 
      }// end loop over 'r'
874
 
      for (unsigned int r = 0; r < 1; r++)
875
 
      {
876
 
        for (unsigned int s = 0; s < 1 - r; s++)
877
 
        {
878
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
879
 
          {
880
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
881
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
882
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
883
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
884
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
885
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
886
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
887
 
          }// end loop over 't'
888
 
        }// end loop over 's'
889
 
      }// end loop over 'r'
890
 
      for (unsigned int r = 0; r < 3; r++)
891
 
      {
892
 
        for (unsigned int s = 0; s < 3 - r; s++)
893
 
        {
894
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
895
 
          {
896
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
897
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
898
 
          }// end loop over 't'
899
 
        }// end loop over 's'
900
 
      }// end loop over 'r'
 
483
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
484
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
485
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
486
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
487
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
488
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
489
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
490
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
491
      basisvalues[0] *= std::sqrt(0.75);
 
492
      basisvalues[3] *= std::sqrt(1.25);
 
493
      basisvalues[9] *= std::sqrt(1.75);
 
494
      basisvalues[2] *= std::sqrt(2.5);
 
495
      basisvalues[8] *= std::sqrt(3.5);
 
496
      basisvalues[7] *= std::sqrt(5.25);
 
497
      basisvalues[1] *= std::sqrt(7.5);
 
498
      basisvalues[6] *= std::sqrt(10.5);
 
499
      basisvalues[5] *= std::sqrt(15.75);
 
500
      basisvalues[4] *= std::sqrt(26.25);
901
501
      
902
502
      // Table(s) of coefficients.
903
503
      static const double coefficients0[10] = \
917
517
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
918
518
      
919
519
      // Declare helper variables.
920
 
      unsigned int rr = 0;
921
 
      unsigned int ss = 0;
922
 
      unsigned int tt = 0;
923
 
      double tmp5 = 0.0;
924
 
      double tmp6 = 0.0;
925
 
      double tmp7 = 0.0;
926
520
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
927
521
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
928
522
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
932
526
      // Compute basisvalues.
933
527
      basisvalues[0] = 1.0;
934
528
      basisvalues[1] = tmp0;
935
 
      for (unsigned int r = 1; r < 2; r++)
936
 
      {
937
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
938
 
        ss = r*(r + 1)*(r + 2)/6;
939
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
940
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
941
 
      }// end loop over 'r'
942
 
      for (unsigned int r = 0; r < 2; r++)
943
 
      {
944
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
945
 
        ss = r*(r + 1)*(r + 2)/6;
946
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
947
 
      }// end loop over 'r'
948
 
      for (unsigned int r = 0; r < 1; r++)
949
 
      {
950
 
        for (unsigned int s = 1; s < 2 - r; s++)
951
 
        {
952
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
953
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
954
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
955
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
956
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
957
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
958
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
959
 
        }// end loop over 's'
960
 
      }// end loop over 'r'
961
 
      for (unsigned int r = 0; r < 2; r++)
962
 
      {
963
 
        for (unsigned int s = 0; s < 2 - r; s++)
964
 
        {
965
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
966
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
967
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
968
 
        }// end loop over 's'
969
 
      }// end loop over 'r'
970
 
      for (unsigned int r = 0; r < 1; r++)
971
 
      {
972
 
        for (unsigned int s = 0; s < 1 - r; s++)
973
 
        {
974
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
975
 
          {
976
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
977
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
978
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
979
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
980
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
981
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
982
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
983
 
          }// end loop over 't'
984
 
        }// end loop over 's'
985
 
      }// end loop over 'r'
986
 
      for (unsigned int r = 0; r < 3; r++)
987
 
      {
988
 
        for (unsigned int s = 0; s < 3 - r; s++)
989
 
        {
990
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
991
 
          {
992
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
993
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
994
 
          }// end loop over 't'
995
 
        }// end loop over 's'
996
 
      }// end loop over 'r'
 
529
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
530
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
531
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
532
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
533
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
534
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
535
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
536
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
537
      basisvalues[0] *= std::sqrt(0.75);
 
538
      basisvalues[3] *= std::sqrt(1.25);
 
539
      basisvalues[9] *= std::sqrt(1.75);
 
540
      basisvalues[2] *= std::sqrt(2.5);
 
541
      basisvalues[8] *= std::sqrt(3.5);
 
542
      basisvalues[7] *= std::sqrt(5.25);
 
543
      basisvalues[1] *= std::sqrt(7.5);
 
544
      basisvalues[6] *= std::sqrt(10.5);
 
545
      basisvalues[5] *= std::sqrt(15.75);
 
546
      basisvalues[4] *= std::sqrt(26.25);
997
547
      
998
548
      // Table(s) of coefficients.
999
549
      static const double coefficients0[10] = \
1013
563
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
1014
564
      
1015
565
      // Declare helper variables.
1016
 
      unsigned int rr = 0;
1017
 
      unsigned int ss = 0;
1018
 
      unsigned int tt = 0;
1019
 
      double tmp5 = 0.0;
1020
 
      double tmp6 = 0.0;
1021
 
      double tmp7 = 0.0;
1022
566
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1023
567
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
1024
568
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
1028
572
      // Compute basisvalues.
1029
573
      basisvalues[0] = 1.0;
1030
574
      basisvalues[1] = tmp0;
1031
 
      for (unsigned int r = 1; r < 2; r++)
1032
 
      {
1033
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
1034
 
        ss = r*(r + 1)*(r + 2)/6;
1035
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
1036
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
1037
 
      }// end loop over 'r'
1038
 
      for (unsigned int r = 0; r < 2; r++)
1039
 
      {
1040
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1041
 
        ss = r*(r + 1)*(r + 2)/6;
1042
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1043
 
      }// end loop over 'r'
1044
 
      for (unsigned int r = 0; r < 1; r++)
1045
 
      {
1046
 
        for (unsigned int s = 1; s < 2 - r; s++)
1047
 
        {
1048
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
1049
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1050
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
1051
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
1052
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
1053
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
1054
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
1055
 
        }// end loop over 's'
1056
 
      }// end loop over 'r'
1057
 
      for (unsigned int r = 0; r < 2; r++)
1058
 
      {
1059
 
        for (unsigned int s = 0; s < 2 - r; s++)
1060
 
        {
1061
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1062
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1063
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1064
 
        }// end loop over 's'
1065
 
      }// end loop over 'r'
1066
 
      for (unsigned int r = 0; r < 1; r++)
1067
 
      {
1068
 
        for (unsigned int s = 0; s < 1 - r; s++)
1069
 
        {
1070
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
1071
 
          {
1072
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
1073
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1074
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
1075
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
1076
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
1077
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
1078
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
1079
 
          }// end loop over 't'
1080
 
        }// end loop over 's'
1081
 
      }// end loop over 'r'
1082
 
      for (unsigned int r = 0; r < 3; r++)
1083
 
      {
1084
 
        for (unsigned int s = 0; s < 3 - r; s++)
1085
 
        {
1086
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
1087
 
          {
1088
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1089
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1090
 
          }// end loop over 't'
1091
 
        }// end loop over 's'
1092
 
      }// end loop over 'r'
 
575
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
576
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
577
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
578
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
579
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
580
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
581
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
582
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
583
      basisvalues[0] *= std::sqrt(0.75);
 
584
      basisvalues[3] *= std::sqrt(1.25);
 
585
      basisvalues[9] *= std::sqrt(1.75);
 
586
      basisvalues[2] *= std::sqrt(2.5);
 
587
      basisvalues[8] *= std::sqrt(3.5);
 
588
      basisvalues[7] *= std::sqrt(5.25);
 
589
      basisvalues[1] *= std::sqrt(7.5);
 
590
      basisvalues[6] *= std::sqrt(10.5);
 
591
      basisvalues[5] *= std::sqrt(15.75);
 
592
      basisvalues[4] *= std::sqrt(26.25);
1093
593
      
1094
594
      // Table(s) of coefficients.
1095
595
      static const double coefficients0[10] = \
1252
752
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
1253
753
      
1254
754
      // Declare helper variables.
1255
 
      unsigned int rr = 0;
1256
 
      unsigned int ss = 0;
1257
 
      unsigned int tt = 0;
1258
 
      double tmp5 = 0.0;
1259
 
      double tmp6 = 0.0;
1260
 
      double tmp7 = 0.0;
1261
755
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1262
756
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
1263
757
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
1267
761
      // Compute basisvalues.
1268
762
      basisvalues[0] = 1.0;
1269
763
      basisvalues[1] = tmp0;
1270
 
      for (unsigned int r = 1; r < 2; r++)
1271
 
      {
1272
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
1273
 
        ss = r*(r + 1)*(r + 2)/6;
1274
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
1275
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
1276
 
      }// end loop over 'r'
1277
 
      for (unsigned int r = 0; r < 2; r++)
1278
 
      {
1279
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1280
 
        ss = r*(r + 1)*(r + 2)/6;
1281
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1282
 
      }// end loop over 'r'
1283
 
      for (unsigned int r = 0; r < 1; r++)
1284
 
      {
1285
 
        for (unsigned int s = 1; s < 2 - r; s++)
1286
 
        {
1287
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
1288
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1289
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
1290
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
1291
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
1292
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
1293
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
1294
 
        }// end loop over 's'
1295
 
      }// end loop over 'r'
1296
 
      for (unsigned int r = 0; r < 2; r++)
1297
 
      {
1298
 
        for (unsigned int s = 0; s < 2 - r; s++)
1299
 
        {
1300
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1301
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1302
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1303
 
        }// end loop over 's'
1304
 
      }// end loop over 'r'
1305
 
      for (unsigned int r = 0; r < 1; r++)
1306
 
      {
1307
 
        for (unsigned int s = 0; s < 1 - r; s++)
1308
 
        {
1309
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
1310
 
          {
1311
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
1312
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1313
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
1314
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
1315
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
1316
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
1317
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
1318
 
          }// end loop over 't'
1319
 
        }// end loop over 's'
1320
 
      }// end loop over 'r'
1321
 
      for (unsigned int r = 0; r < 3; r++)
1322
 
      {
1323
 
        for (unsigned int s = 0; s < 3 - r; s++)
1324
 
        {
1325
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
1326
 
          {
1327
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1328
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1329
 
          }// end loop over 't'
1330
 
        }// end loop over 's'
1331
 
      }// end loop over 'r'
 
764
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
765
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
766
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
767
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
768
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
769
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
770
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
771
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
772
      basisvalues[0] *= std::sqrt(0.75);
 
773
      basisvalues[3] *= std::sqrt(1.25);
 
774
      basisvalues[9] *= std::sqrt(1.75);
 
775
      basisvalues[2] *= std::sqrt(2.5);
 
776
      basisvalues[8] *= std::sqrt(3.5);
 
777
      basisvalues[7] *= std::sqrt(5.25);
 
778
      basisvalues[1] *= std::sqrt(7.5);
 
779
      basisvalues[6] *= std::sqrt(10.5);
 
780
      basisvalues[5] *= std::sqrt(15.75);
 
781
      basisvalues[4] *= std::sqrt(26.25);
1332
782
      
1333
783
      // Table(s) of coefficients.
1334
784
      static const double coefficients0[10] = \
1520
970
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
1521
971
      
1522
972
      // Declare helper variables.
1523
 
      unsigned int rr = 0;
1524
 
      unsigned int ss = 0;
1525
 
      unsigned int tt = 0;
1526
 
      double tmp5 = 0.0;
1527
 
      double tmp6 = 0.0;
1528
 
      double tmp7 = 0.0;
1529
973
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1530
974
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
1531
975
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
1535
979
      // Compute basisvalues.
1536
980
      basisvalues[0] = 1.0;
1537
981
      basisvalues[1] = tmp0;
1538
 
      for (unsigned int r = 1; r < 2; r++)
1539
 
      {
1540
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
1541
 
        ss = r*(r + 1)*(r + 2)/6;
1542
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
1543
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
1544
 
      }// end loop over 'r'
1545
 
      for (unsigned int r = 0; r < 2; r++)
1546
 
      {
1547
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1548
 
        ss = r*(r + 1)*(r + 2)/6;
1549
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1550
 
      }// end loop over 'r'
1551
 
      for (unsigned int r = 0; r < 1; r++)
1552
 
      {
1553
 
        for (unsigned int s = 1; s < 2 - r; s++)
1554
 
        {
1555
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
1556
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1557
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
1558
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
1559
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
1560
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
1561
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
1562
 
        }// end loop over 's'
1563
 
      }// end loop over 'r'
1564
 
      for (unsigned int r = 0; r < 2; r++)
1565
 
      {
1566
 
        for (unsigned int s = 0; s < 2 - r; s++)
1567
 
        {
1568
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1569
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1570
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1571
 
        }// end loop over 's'
1572
 
      }// end loop over 'r'
1573
 
      for (unsigned int r = 0; r < 1; r++)
1574
 
      {
1575
 
        for (unsigned int s = 0; s < 1 - r; s++)
1576
 
        {
1577
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
1578
 
          {
1579
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
1580
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1581
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
1582
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
1583
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
1584
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
1585
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
1586
 
          }// end loop over 't'
1587
 
        }// end loop over 's'
1588
 
      }// end loop over 'r'
1589
 
      for (unsigned int r = 0; r < 3; r++)
1590
 
      {
1591
 
        for (unsigned int s = 0; s < 3 - r; s++)
1592
 
        {
1593
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
1594
 
          {
1595
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1596
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1597
 
          }// end loop over 't'
1598
 
        }// end loop over 's'
1599
 
      }// end loop over 'r'
 
982
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
983
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
984
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
985
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
986
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
987
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
988
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
989
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
990
      basisvalues[0] *= std::sqrt(0.75);
 
991
      basisvalues[3] *= std::sqrt(1.25);
 
992
      basisvalues[9] *= std::sqrt(1.75);
 
993
      basisvalues[2] *= std::sqrt(2.5);
 
994
      basisvalues[8] *= std::sqrt(3.5);
 
995
      basisvalues[7] *= std::sqrt(5.25);
 
996
      basisvalues[1] *= std::sqrt(7.5);
 
997
      basisvalues[6] *= std::sqrt(10.5);
 
998
      basisvalues[5] *= std::sqrt(15.75);
 
999
      basisvalues[4] *= std::sqrt(26.25);
1600
1000
      
1601
1001
      // Table(s) of coefficients.
1602
1002
      static const double coefficients0[10] = \
1788
1188
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
1789
1189
      
1790
1190
      // Declare helper variables.
1791
 
      unsigned int rr = 0;
1792
 
      unsigned int ss = 0;
1793
 
      unsigned int tt = 0;
1794
 
      double tmp5 = 0.0;
1795
 
      double tmp6 = 0.0;
1796
 
      double tmp7 = 0.0;
1797
1191
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1798
1192
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
1799
1193
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
1803
1197
      // Compute basisvalues.
1804
1198
      basisvalues[0] = 1.0;
1805
1199
      basisvalues[1] = tmp0;
1806
 
      for (unsigned int r = 1; r < 2; r++)
1807
 
      {
1808
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
1809
 
        ss = r*(r + 1)*(r + 2)/6;
1810
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
1811
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
1812
 
      }// end loop over 'r'
1813
 
      for (unsigned int r = 0; r < 2; r++)
1814
 
      {
1815
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1816
 
        ss = r*(r + 1)*(r + 2)/6;
1817
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1818
 
      }// end loop over 'r'
1819
 
      for (unsigned int r = 0; r < 1; r++)
1820
 
      {
1821
 
        for (unsigned int s = 1; s < 2 - r; s++)
1822
 
        {
1823
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
1824
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1825
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
1826
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
1827
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
1828
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
1829
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
1830
 
        }// end loop over 's'
1831
 
      }// end loop over 'r'
1832
 
      for (unsigned int r = 0; r < 2; r++)
1833
 
      {
1834
 
        for (unsigned int s = 0; s < 2 - r; s++)
1835
 
        {
1836
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1837
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1838
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1839
 
        }// end loop over 's'
1840
 
      }// end loop over 'r'
1841
 
      for (unsigned int r = 0; r < 1; r++)
1842
 
      {
1843
 
        for (unsigned int s = 0; s < 1 - r; s++)
1844
 
        {
1845
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
1846
 
          {
1847
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
1848
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1849
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
1850
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
1851
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
1852
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
1853
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
1854
 
          }// end loop over 't'
1855
 
        }// end loop over 's'
1856
 
      }// end loop over 'r'
1857
 
      for (unsigned int r = 0; r < 3; r++)
1858
 
      {
1859
 
        for (unsigned int s = 0; s < 3 - r; s++)
1860
 
        {
1861
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
1862
 
          {
1863
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1864
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1865
 
          }// end loop over 't'
1866
 
        }// end loop over 's'
1867
 
      }// end loop over 'r'
 
1200
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
1201
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1202
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
1203
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
1204
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1205
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
1206
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
1207
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
1208
      basisvalues[0] *= std::sqrt(0.75);
 
1209
      basisvalues[3] *= std::sqrt(1.25);
 
1210
      basisvalues[9] *= std::sqrt(1.75);
 
1211
      basisvalues[2] *= std::sqrt(2.5);
 
1212
      basisvalues[8] *= std::sqrt(3.5);
 
1213
      basisvalues[7] *= std::sqrt(5.25);
 
1214
      basisvalues[1] *= std::sqrt(7.5);
 
1215
      basisvalues[6] *= std::sqrt(10.5);
 
1216
      basisvalues[5] *= std::sqrt(15.75);
 
1217
      basisvalues[4] *= std::sqrt(26.25);
1868
1218
      
1869
1219
      // Table(s) of coefficients.
1870
1220
      static const double coefficients0[10] = \
2056
1406
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
2057
1407
      
2058
1408
      // Declare helper variables.
2059
 
      unsigned int rr = 0;
2060
 
      unsigned int ss = 0;
2061
 
      unsigned int tt = 0;
2062
 
      double tmp5 = 0.0;
2063
 
      double tmp6 = 0.0;
2064
 
      double tmp7 = 0.0;
2065
1409
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2066
1410
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
2067
1411
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
2071
1415
      // Compute basisvalues.
2072
1416
      basisvalues[0] = 1.0;
2073
1417
      basisvalues[1] = tmp0;
2074
 
      for (unsigned int r = 1; r < 2; r++)
2075
 
      {
2076
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
2077
 
        ss = r*(r + 1)*(r + 2)/6;
2078
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
2079
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
2080
 
      }// end loop over 'r'
2081
 
      for (unsigned int r = 0; r < 2; r++)
2082
 
      {
2083
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2084
 
        ss = r*(r + 1)*(r + 2)/6;
2085
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2086
 
      }// end loop over 'r'
2087
 
      for (unsigned int r = 0; r < 1; r++)
2088
 
      {
2089
 
        for (unsigned int s = 1; s < 2 - r; s++)
2090
 
        {
2091
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
2092
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2093
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
2094
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
2095
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
2096
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
2097
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
2098
 
        }// end loop over 's'
2099
 
      }// end loop over 'r'
2100
 
      for (unsigned int r = 0; r < 2; r++)
2101
 
      {
2102
 
        for (unsigned int s = 0; s < 2 - r; s++)
2103
 
        {
2104
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2105
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2106
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2107
 
        }// end loop over 's'
2108
 
      }// end loop over 'r'
2109
 
      for (unsigned int r = 0; r < 1; r++)
2110
 
      {
2111
 
        for (unsigned int s = 0; s < 1 - r; s++)
2112
 
        {
2113
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
2114
 
          {
2115
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
2116
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2117
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
2118
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
2119
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
2120
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
2121
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
2122
 
          }// end loop over 't'
2123
 
        }// end loop over 's'
2124
 
      }// end loop over 'r'
2125
 
      for (unsigned int r = 0; r < 3; r++)
2126
 
      {
2127
 
        for (unsigned int s = 0; s < 3 - r; s++)
2128
 
        {
2129
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
2130
 
          {
2131
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2132
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2133
 
          }// end loop over 't'
2134
 
        }// end loop over 's'
2135
 
      }// end loop over 'r'
 
1418
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
1419
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1420
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
1421
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
1422
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1423
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
1424
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
1425
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
1426
      basisvalues[0] *= std::sqrt(0.75);
 
1427
      basisvalues[3] *= std::sqrt(1.25);
 
1428
      basisvalues[9] *= std::sqrt(1.75);
 
1429
      basisvalues[2] *= std::sqrt(2.5);
 
1430
      basisvalues[8] *= std::sqrt(3.5);
 
1431
      basisvalues[7] *= std::sqrt(5.25);
 
1432
      basisvalues[1] *= std::sqrt(7.5);
 
1433
      basisvalues[6] *= std::sqrt(10.5);
 
1434
      basisvalues[5] *= std::sqrt(15.75);
 
1435
      basisvalues[4] *= std::sqrt(26.25);
2136
1436
      
2137
1437
      // Table(s) of coefficients.
2138
1438
      static const double coefficients0[10] = \
2324
1624
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
2325
1625
      
2326
1626
      // Declare helper variables.
2327
 
      unsigned int rr = 0;
2328
 
      unsigned int ss = 0;
2329
 
      unsigned int tt = 0;
2330
 
      double tmp5 = 0.0;
2331
 
      double tmp6 = 0.0;
2332
 
      double tmp7 = 0.0;
2333
1627
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2334
1628
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
2335
1629
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
2339
1633
      // Compute basisvalues.
2340
1634
      basisvalues[0] = 1.0;
2341
1635
      basisvalues[1] = tmp0;
2342
 
      for (unsigned int r = 1; r < 2; r++)
2343
 
      {
2344
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
2345
 
        ss = r*(r + 1)*(r + 2)/6;
2346
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
2347
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
2348
 
      }// end loop over 'r'
2349
 
      for (unsigned int r = 0; r < 2; r++)
2350
 
      {
2351
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2352
 
        ss = r*(r + 1)*(r + 2)/6;
2353
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2354
 
      }// end loop over 'r'
2355
 
      for (unsigned int r = 0; r < 1; r++)
2356
 
      {
2357
 
        for (unsigned int s = 1; s < 2 - r; s++)
2358
 
        {
2359
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
2360
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2361
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
2362
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
2363
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
2364
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
2365
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
2366
 
        }// end loop over 's'
2367
 
      }// end loop over 'r'
2368
 
      for (unsigned int r = 0; r < 2; r++)
2369
 
      {
2370
 
        for (unsigned int s = 0; s < 2 - r; s++)
2371
 
        {
2372
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2373
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2374
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2375
 
        }// end loop over 's'
2376
 
      }// end loop over 'r'
2377
 
      for (unsigned int r = 0; r < 1; r++)
2378
 
      {
2379
 
        for (unsigned int s = 0; s < 1 - r; s++)
2380
 
        {
2381
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
2382
 
          {
2383
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
2384
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2385
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
2386
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
2387
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
2388
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
2389
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
2390
 
          }// end loop over 't'
2391
 
        }// end loop over 's'
2392
 
      }// end loop over 'r'
2393
 
      for (unsigned int r = 0; r < 3; r++)
2394
 
      {
2395
 
        for (unsigned int s = 0; s < 3 - r; s++)
2396
 
        {
2397
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
2398
 
          {
2399
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2400
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2401
 
          }// end loop over 't'
2402
 
        }// end loop over 's'
2403
 
      }// end loop over 'r'
 
1636
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
1637
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1638
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
1639
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
1640
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1641
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
1642
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
1643
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
1644
      basisvalues[0] *= std::sqrt(0.75);
 
1645
      basisvalues[3] *= std::sqrt(1.25);
 
1646
      basisvalues[9] *= std::sqrt(1.75);
 
1647
      basisvalues[2] *= std::sqrt(2.5);
 
1648
      basisvalues[8] *= std::sqrt(3.5);
 
1649
      basisvalues[7] *= std::sqrt(5.25);
 
1650
      basisvalues[1] *= std::sqrt(7.5);
 
1651
      basisvalues[6] *= std::sqrt(10.5);
 
1652
      basisvalues[5] *= std::sqrt(15.75);
 
1653
      basisvalues[4] *= std::sqrt(26.25);
2404
1654
      
2405
1655
      // Table(s) of coefficients.
2406
1656
      static const double coefficients0[10] = \
2592
1842
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
2593
1843
      
2594
1844
      // Declare helper variables.
2595
 
      unsigned int rr = 0;
2596
 
      unsigned int ss = 0;
2597
 
      unsigned int tt = 0;
2598
 
      double tmp5 = 0.0;
2599
 
      double tmp6 = 0.0;
2600
 
      double tmp7 = 0.0;
2601
1845
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2602
1846
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
2603
1847
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
2607
1851
      // Compute basisvalues.
2608
1852
      basisvalues[0] = 1.0;
2609
1853
      basisvalues[1] = tmp0;
2610
 
      for (unsigned int r = 1; r < 2; r++)
2611
 
      {
2612
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
2613
 
        ss = r*(r + 1)*(r + 2)/6;
2614
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
2615
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
2616
 
      }// end loop over 'r'
2617
 
      for (unsigned int r = 0; r < 2; r++)
2618
 
      {
2619
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2620
 
        ss = r*(r + 1)*(r + 2)/6;
2621
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2622
 
      }// end loop over 'r'
2623
 
      for (unsigned int r = 0; r < 1; r++)
2624
 
      {
2625
 
        for (unsigned int s = 1; s < 2 - r; s++)
2626
 
        {
2627
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
2628
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2629
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
2630
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
2631
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
2632
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
2633
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
2634
 
        }// end loop over 's'
2635
 
      }// end loop over 'r'
2636
 
      for (unsigned int r = 0; r < 2; r++)
2637
 
      {
2638
 
        for (unsigned int s = 0; s < 2 - r; s++)
2639
 
        {
2640
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2641
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2642
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2643
 
        }// end loop over 's'
2644
 
      }// end loop over 'r'
2645
 
      for (unsigned int r = 0; r < 1; r++)
2646
 
      {
2647
 
        for (unsigned int s = 0; s < 1 - r; s++)
2648
 
        {
2649
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
2650
 
          {
2651
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
2652
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2653
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
2654
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
2655
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
2656
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
2657
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
2658
 
          }// end loop over 't'
2659
 
        }// end loop over 's'
2660
 
      }// end loop over 'r'
2661
 
      for (unsigned int r = 0; r < 3; r++)
2662
 
      {
2663
 
        for (unsigned int s = 0; s < 3 - r; s++)
2664
 
        {
2665
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
2666
 
          {
2667
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2668
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2669
 
          }// end loop over 't'
2670
 
        }// end loop over 's'
2671
 
      }// end loop over 'r'
 
1854
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
1855
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1856
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
1857
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
1858
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1859
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
1860
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
1861
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
1862
      basisvalues[0] *= std::sqrt(0.75);
 
1863
      basisvalues[3] *= std::sqrt(1.25);
 
1864
      basisvalues[9] *= std::sqrt(1.75);
 
1865
      basisvalues[2] *= std::sqrt(2.5);
 
1866
      basisvalues[8] *= std::sqrt(3.5);
 
1867
      basisvalues[7] *= std::sqrt(5.25);
 
1868
      basisvalues[1] *= std::sqrt(7.5);
 
1869
      basisvalues[6] *= std::sqrt(10.5);
 
1870
      basisvalues[5] *= std::sqrt(15.75);
 
1871
      basisvalues[4] *= std::sqrt(26.25);
2672
1872
      
2673
1873
      // Table(s) of coefficients.
2674
1874
      static const double coefficients0[10] = \
2860
2060
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
2861
2061
      
2862
2062
      // Declare helper variables.
2863
 
      unsigned int rr = 0;
2864
 
      unsigned int ss = 0;
2865
 
      unsigned int tt = 0;
2866
 
      double tmp5 = 0.0;
2867
 
      double tmp6 = 0.0;
2868
 
      double tmp7 = 0.0;
2869
2063
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2870
2064
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
2871
2065
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
2875
2069
      // Compute basisvalues.
2876
2070
      basisvalues[0] = 1.0;
2877
2071
      basisvalues[1] = tmp0;
2878
 
      for (unsigned int r = 1; r < 2; r++)
2879
 
      {
2880
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
2881
 
        ss = r*(r + 1)*(r + 2)/6;
2882
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
2883
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
2884
 
      }// end loop over 'r'
2885
 
      for (unsigned int r = 0; r < 2; r++)
2886
 
      {
2887
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2888
 
        ss = r*(r + 1)*(r + 2)/6;
2889
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2890
 
      }// end loop over 'r'
2891
 
      for (unsigned int r = 0; r < 1; r++)
2892
 
      {
2893
 
        for (unsigned int s = 1; s < 2 - r; s++)
2894
 
        {
2895
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
2896
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2897
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
2898
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
2899
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
2900
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
2901
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
2902
 
        }// end loop over 's'
2903
 
      }// end loop over 'r'
2904
 
      for (unsigned int r = 0; r < 2; r++)
2905
 
      {
2906
 
        for (unsigned int s = 0; s < 2 - r; s++)
2907
 
        {
2908
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2909
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2910
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2911
 
        }// end loop over 's'
2912
 
      }// end loop over 'r'
2913
 
      for (unsigned int r = 0; r < 1; r++)
2914
 
      {
2915
 
        for (unsigned int s = 0; s < 1 - r; s++)
2916
 
        {
2917
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
2918
 
          {
2919
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
2920
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2921
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
2922
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
2923
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
2924
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
2925
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
2926
 
          }// end loop over 't'
2927
 
        }// end loop over 's'
2928
 
      }// end loop over 'r'
2929
 
      for (unsigned int r = 0; r < 3; r++)
2930
 
      {
2931
 
        for (unsigned int s = 0; s < 3 - r; s++)
2932
 
        {
2933
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
2934
 
          {
2935
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2936
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2937
 
          }// end loop over 't'
2938
 
        }// end loop over 's'
2939
 
      }// end loop over 'r'
 
2072
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
2073
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
2074
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
2075
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
2076
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
2077
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
2078
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
2079
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
2080
      basisvalues[0] *= std::sqrt(0.75);
 
2081
      basisvalues[3] *= std::sqrt(1.25);
 
2082
      basisvalues[9] *= std::sqrt(1.75);
 
2083
      basisvalues[2] *= std::sqrt(2.5);
 
2084
      basisvalues[8] *= std::sqrt(3.5);
 
2085
      basisvalues[7] *= std::sqrt(5.25);
 
2086
      basisvalues[1] *= std::sqrt(7.5);
 
2087
      basisvalues[6] *= std::sqrt(10.5);
 
2088
      basisvalues[5] *= std::sqrt(15.75);
 
2089
      basisvalues[4] *= std::sqrt(26.25);
2940
2090
      
2941
2091
      // Table(s) of coefficients.
2942
2092
      static const double coefficients0[10] = \
3128
2278
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
3129
2279
      
3130
2280
      // Declare helper variables.
3131
 
      unsigned int rr = 0;
3132
 
      unsigned int ss = 0;
3133
 
      unsigned int tt = 0;
3134
 
      double tmp5 = 0.0;
3135
 
      double tmp6 = 0.0;
3136
 
      double tmp7 = 0.0;
3137
2281
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
3138
2282
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
3139
2283
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
3143
2287
      // Compute basisvalues.
3144
2288
      basisvalues[0] = 1.0;
3145
2289
      basisvalues[1] = tmp0;
3146
 
      for (unsigned int r = 1; r < 2; r++)
3147
 
      {
3148
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
3149
 
        ss = r*(r + 1)*(r + 2)/6;
3150
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
3151
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
3152
 
      }// end loop over 'r'
3153
 
      for (unsigned int r = 0; r < 2; r++)
3154
 
      {
3155
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
3156
 
        ss = r*(r + 1)*(r + 2)/6;
3157
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
3158
 
      }// end loop over 'r'
3159
 
      for (unsigned int r = 0; r < 1; r++)
3160
 
      {
3161
 
        for (unsigned int s = 1; s < 2 - r; s++)
3162
 
        {
3163
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
3164
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3165
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
3166
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
3167
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
3168
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
3169
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
3170
 
        }// end loop over 's'
3171
 
      }// end loop over 'r'
3172
 
      for (unsigned int r = 0; r < 2; r++)
3173
 
      {
3174
 
        for (unsigned int s = 0; s < 2 - r; s++)
3175
 
        {
3176
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
3177
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3178
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
3179
 
        }// end loop over 's'
3180
 
      }// end loop over 'r'
3181
 
      for (unsigned int r = 0; r < 1; r++)
3182
 
      {
3183
 
        for (unsigned int s = 0; s < 1 - r; s++)
3184
 
        {
3185
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
3186
 
          {
3187
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
3188
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3189
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
3190
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
3191
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
3192
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
3193
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
3194
 
          }// end loop over 't'
3195
 
        }// end loop over 's'
3196
 
      }// end loop over 'r'
3197
 
      for (unsigned int r = 0; r < 3; r++)
3198
 
      {
3199
 
        for (unsigned int s = 0; s < 3 - r; s++)
3200
 
        {
3201
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
3202
 
          {
3203
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3204
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
3205
 
          }// end loop over 't'
3206
 
        }// end loop over 's'
3207
 
      }// end loop over 'r'
 
2290
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
2291
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
2292
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
2293
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
2294
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
2295
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
2296
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
2297
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
2298
      basisvalues[0] *= std::sqrt(0.75);
 
2299
      basisvalues[3] *= std::sqrt(1.25);
 
2300
      basisvalues[9] *= std::sqrt(1.75);
 
2301
      basisvalues[2] *= std::sqrt(2.5);
 
2302
      basisvalues[8] *= std::sqrt(3.5);
 
2303
      basisvalues[7] *= std::sqrt(5.25);
 
2304
      basisvalues[1] *= std::sqrt(7.5);
 
2305
      basisvalues[6] *= std::sqrt(10.5);
 
2306
      basisvalues[5] *= std::sqrt(15.75);
 
2307
      basisvalues[4] *= std::sqrt(26.25);
3208
2308
      
3209
2309
      // Table(s) of coefficients.
3210
2310
      static const double coefficients0[10] = \
3396
2496
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
3397
2497
      
3398
2498
      // Declare helper variables.
3399
 
      unsigned int rr = 0;
3400
 
      unsigned int ss = 0;
3401
 
      unsigned int tt = 0;
3402
 
      double tmp5 = 0.0;
3403
 
      double tmp6 = 0.0;
3404
 
      double tmp7 = 0.0;
3405
2499
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
3406
2500
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
3407
2501
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
3411
2505
      // Compute basisvalues.
3412
2506
      basisvalues[0] = 1.0;
3413
2507
      basisvalues[1] = tmp0;
3414
 
      for (unsigned int r = 1; r < 2; r++)
3415
 
      {
3416
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
3417
 
        ss = r*(r + 1)*(r + 2)/6;
3418
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
3419
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
3420
 
      }// end loop over 'r'
3421
 
      for (unsigned int r = 0; r < 2; r++)
3422
 
      {
3423
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
3424
 
        ss = r*(r + 1)*(r + 2)/6;
3425
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
3426
 
      }// end loop over 'r'
3427
 
      for (unsigned int r = 0; r < 1; r++)
3428
 
      {
3429
 
        for (unsigned int s = 1; s < 2 - r; s++)
3430
 
        {
3431
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
3432
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3433
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
3434
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
3435
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
3436
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
3437
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
3438
 
        }// end loop over 's'
3439
 
      }// end loop over 'r'
3440
 
      for (unsigned int r = 0; r < 2; r++)
3441
 
      {
3442
 
        for (unsigned int s = 0; s < 2 - r; s++)
3443
 
        {
3444
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
3445
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3446
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
3447
 
        }// end loop over 's'
3448
 
      }// end loop over 'r'
3449
 
      for (unsigned int r = 0; r < 1; r++)
3450
 
      {
3451
 
        for (unsigned int s = 0; s < 1 - r; s++)
3452
 
        {
3453
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
3454
 
          {
3455
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
3456
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3457
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
3458
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
3459
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
3460
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
3461
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
3462
 
          }// end loop over 't'
3463
 
        }// end loop over 's'
3464
 
      }// end loop over 'r'
3465
 
      for (unsigned int r = 0; r < 3; r++)
3466
 
      {
3467
 
        for (unsigned int s = 0; s < 3 - r; s++)
3468
 
        {
3469
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
3470
 
          {
3471
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3472
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
3473
 
          }// end loop over 't'
3474
 
        }// end loop over 's'
3475
 
      }// end loop over 'r'
 
2508
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
2509
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
2510
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
2511
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
2512
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
2513
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
2514
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
2515
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
2516
      basisvalues[0] *= std::sqrt(0.75);
 
2517
      basisvalues[3] *= std::sqrt(1.25);
 
2518
      basisvalues[9] *= std::sqrt(1.75);
 
2519
      basisvalues[2] *= std::sqrt(2.5);
 
2520
      basisvalues[8] *= std::sqrt(3.5);
 
2521
      basisvalues[7] *= std::sqrt(5.25);
 
2522
      basisvalues[1] *= std::sqrt(7.5);
 
2523
      basisvalues[6] *= std::sqrt(10.5);
 
2524
      basisvalues[5] *= std::sqrt(15.75);
 
2525
      basisvalues[4] *= std::sqrt(26.25);
3476
2526
      
3477
2527
      // Table(s) of coefficients.
3478
2528
      static const double coefficients0[10] = \
3664
2714
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
3665
2715
      
3666
2716
      // Declare helper variables.
3667
 
      unsigned int rr = 0;
3668
 
      unsigned int ss = 0;
3669
 
      unsigned int tt = 0;
3670
 
      double tmp5 = 0.0;
3671
 
      double tmp6 = 0.0;
3672
 
      double tmp7 = 0.0;
3673
2717
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
3674
2718
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
3675
2719
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
3679
2723
      // Compute basisvalues.
3680
2724
      basisvalues[0] = 1.0;
3681
2725
      basisvalues[1] = tmp0;
3682
 
      for (unsigned int r = 1; r < 2; r++)
3683
 
      {
3684
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
3685
 
        ss = r*(r + 1)*(r + 2)/6;
3686
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
3687
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
3688
 
      }// end loop over 'r'
3689
 
      for (unsigned int r = 0; r < 2; r++)
3690
 
      {
3691
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
3692
 
        ss = r*(r + 1)*(r + 2)/6;
3693
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
3694
 
      }// end loop over 'r'
3695
 
      for (unsigned int r = 0; r < 1; r++)
3696
 
      {
3697
 
        for (unsigned int s = 1; s < 2 - r; s++)
3698
 
        {
3699
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
3700
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3701
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
3702
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
3703
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
3704
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
3705
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
3706
 
        }// end loop over 's'
3707
 
      }// end loop over 'r'
3708
 
      for (unsigned int r = 0; r < 2; r++)
3709
 
      {
3710
 
        for (unsigned int s = 0; s < 2 - r; s++)
3711
 
        {
3712
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
3713
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3714
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
3715
 
        }// end loop over 's'
3716
 
      }// end loop over 'r'
3717
 
      for (unsigned int r = 0; r < 1; r++)
3718
 
      {
3719
 
        for (unsigned int s = 0; s < 1 - r; s++)
3720
 
        {
3721
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
3722
 
          {
3723
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
3724
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3725
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
3726
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
3727
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
3728
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
3729
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
3730
 
          }// end loop over 't'
3731
 
        }// end loop over 's'
3732
 
      }// end loop over 'r'
3733
 
      for (unsigned int r = 0; r < 3; r++)
3734
 
      {
3735
 
        for (unsigned int s = 0; s < 3 - r; s++)
3736
 
        {
3737
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
3738
 
          {
3739
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3740
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
3741
 
          }// end loop over 't'
3742
 
        }// end loop over 's'
3743
 
      }// end loop over 'r'
 
2726
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
2727
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
2728
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
2729
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
2730
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
2731
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
2732
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
2733
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
2734
      basisvalues[0] *= std::sqrt(0.75);
 
2735
      basisvalues[3] *= std::sqrt(1.25);
 
2736
      basisvalues[9] *= std::sqrt(1.75);
 
2737
      basisvalues[2] *= std::sqrt(2.5);
 
2738
      basisvalues[8] *= std::sqrt(3.5);
 
2739
      basisvalues[7] *= std::sqrt(5.25);
 
2740
      basisvalues[1] *= std::sqrt(7.5);
 
2741
      basisvalues[6] *= std::sqrt(10.5);
 
2742
      basisvalues[5] *= std::sqrt(15.75);
 
2743
      basisvalues[4] *= std::sqrt(26.25);
3744
2744
      
3745
2745
      // Table(s) of coefficients.
3746
2746
      static const double coefficients0[10] = \
4311
3311
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
4312
3312
      
4313
3313
      // Declare helper variables.
4314
 
      unsigned int rr = 0;
4315
 
      unsigned int ss = 0;
4316
 
      unsigned int tt = 0;
4317
 
      double tmp5 = 0.0;
4318
 
      double tmp6 = 0.0;
4319
 
      double tmp7 = 0.0;
4320
3314
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4321
3315
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
4322
3316
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
4326
3320
      // Compute basisvalues.
4327
3321
      basisvalues[0] = 1.0;
4328
3322
      basisvalues[1] = tmp0;
4329
 
      for (unsigned int r = 1; r < 2; r++)
4330
 
      {
4331
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
4332
 
        ss = r*(r + 1)*(r + 2)/6;
4333
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
4334
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
4335
 
      }// end loop over 'r'
4336
 
      for (unsigned int r = 0; r < 2; r++)
4337
 
      {
4338
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
4339
 
        ss = r*(r + 1)*(r + 2)/6;
4340
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
4341
 
      }// end loop over 'r'
4342
 
      for (unsigned int r = 0; r < 1; r++)
4343
 
      {
4344
 
        for (unsigned int s = 1; s < 2 - r; s++)
4345
 
        {
4346
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
4347
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4348
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
4349
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
4350
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4351
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4352
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
4353
 
        }// end loop over 's'
4354
 
      }// end loop over 'r'
4355
 
      for (unsigned int r = 0; r < 2; r++)
4356
 
      {
4357
 
        for (unsigned int s = 0; s < 2 - r; s++)
4358
 
        {
4359
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
4360
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4361
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
4362
 
        }// end loop over 's'
4363
 
      }// end loop over 'r'
4364
 
      for (unsigned int r = 0; r < 1; r++)
4365
 
      {
4366
 
        for (unsigned int s = 0; s < 1 - r; s++)
4367
 
        {
4368
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
4369
 
          {
4370
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
4371
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4372
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
4373
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
4374
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4375
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4376
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
4377
 
          }// end loop over 't'
4378
 
        }// end loop over 's'
4379
 
      }// end loop over 'r'
4380
 
      for (unsigned int r = 0; r < 3; r++)
4381
 
      {
4382
 
        for (unsigned int s = 0; s < 3 - r; s++)
4383
 
        {
4384
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
4385
 
          {
4386
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4387
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
4388
 
          }// end loop over 't'
4389
 
        }// end loop over 's'
4390
 
      }// end loop over 'r'
 
3323
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3324
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3325
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3326
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3327
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3328
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3329
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3330
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3331
      basisvalues[0] *= std::sqrt(0.75);
 
3332
      basisvalues[3] *= std::sqrt(1.25);
 
3333
      basisvalues[9] *= std::sqrt(1.75);
 
3334
      basisvalues[2] *= std::sqrt(2.5);
 
3335
      basisvalues[8] *= std::sqrt(3.5);
 
3336
      basisvalues[7] *= std::sqrt(5.25);
 
3337
      basisvalues[1] *= std::sqrt(7.5);
 
3338
      basisvalues[6] *= std::sqrt(10.5);
 
3339
      basisvalues[5] *= std::sqrt(15.75);
 
3340
      basisvalues[4] *= std::sqrt(26.25);
4391
3341
      
4392
3342
      // Table(s) of coefficients.
4393
3343
      static const double coefficients0[10] = \
4407
3357
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
4408
3358
      
4409
3359
      // Declare helper variables.
4410
 
      unsigned int rr = 0;
4411
 
      unsigned int ss = 0;
4412
 
      unsigned int tt = 0;
4413
 
      double tmp5 = 0.0;
4414
 
      double tmp6 = 0.0;
4415
 
      double tmp7 = 0.0;
4416
3360
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4417
3361
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
4418
3362
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
4422
3366
      // Compute basisvalues.
4423
3367
      basisvalues[0] = 1.0;
4424
3368
      basisvalues[1] = tmp0;
4425
 
      for (unsigned int r = 1; r < 2; r++)
4426
 
      {
4427
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
4428
 
        ss = r*(r + 1)*(r + 2)/6;
4429
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
4430
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
4431
 
      }// end loop over 'r'
4432
 
      for (unsigned int r = 0; r < 2; r++)
4433
 
      {
4434
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
4435
 
        ss = r*(r + 1)*(r + 2)/6;
4436
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
4437
 
      }// end loop over 'r'
4438
 
      for (unsigned int r = 0; r < 1; r++)
4439
 
      {
4440
 
        for (unsigned int s = 1; s < 2 - r; s++)
4441
 
        {
4442
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
4443
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4444
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
4445
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
4446
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4447
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4448
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
4449
 
        }// end loop over 's'
4450
 
      }// end loop over 'r'
4451
 
      for (unsigned int r = 0; r < 2; r++)
4452
 
      {
4453
 
        for (unsigned int s = 0; s < 2 - r; s++)
4454
 
        {
4455
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
4456
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4457
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
4458
 
        }// end loop over 's'
4459
 
      }// end loop over 'r'
4460
 
      for (unsigned int r = 0; r < 1; r++)
4461
 
      {
4462
 
        for (unsigned int s = 0; s < 1 - r; s++)
4463
 
        {
4464
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
4465
 
          {
4466
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
4467
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4468
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
4469
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
4470
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4471
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4472
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
4473
 
          }// end loop over 't'
4474
 
        }// end loop over 's'
4475
 
      }// end loop over 'r'
4476
 
      for (unsigned int r = 0; r < 3; r++)
4477
 
      {
4478
 
        for (unsigned int s = 0; s < 3 - r; s++)
4479
 
        {
4480
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
4481
 
          {
4482
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4483
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
4484
 
          }// end loop over 't'
4485
 
        }// end loop over 's'
4486
 
      }// end loop over 'r'
 
3369
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3370
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3371
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3372
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3373
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3374
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3375
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3376
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3377
      basisvalues[0] *= std::sqrt(0.75);
 
3378
      basisvalues[3] *= std::sqrt(1.25);
 
3379
      basisvalues[9] *= std::sqrt(1.75);
 
3380
      basisvalues[2] *= std::sqrt(2.5);
 
3381
      basisvalues[8] *= std::sqrt(3.5);
 
3382
      basisvalues[7] *= std::sqrt(5.25);
 
3383
      basisvalues[1] *= std::sqrt(7.5);
 
3384
      basisvalues[6] *= std::sqrt(10.5);
 
3385
      basisvalues[5] *= std::sqrt(15.75);
 
3386
      basisvalues[4] *= std::sqrt(26.25);
4487
3387
      
4488
3388
      // Table(s) of coefficients.
4489
3389
      static const double coefficients0[10] = \
4503
3403
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
4504
3404
      
4505
3405
      // Declare helper variables.
4506
 
      unsigned int rr = 0;
4507
 
      unsigned int ss = 0;
4508
 
      unsigned int tt = 0;
4509
 
      double tmp5 = 0.0;
4510
 
      double tmp6 = 0.0;
4511
 
      double tmp7 = 0.0;
4512
3406
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4513
3407
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
4514
3408
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
4518
3412
      // Compute basisvalues.
4519
3413
      basisvalues[0] = 1.0;
4520
3414
      basisvalues[1] = tmp0;
4521
 
      for (unsigned int r = 1; r < 2; r++)
4522
 
      {
4523
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
4524
 
        ss = r*(r + 1)*(r + 2)/6;
4525
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
4526
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
4527
 
      }// end loop over 'r'
4528
 
      for (unsigned int r = 0; r < 2; r++)
4529
 
      {
4530
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
4531
 
        ss = r*(r + 1)*(r + 2)/6;
4532
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
4533
 
      }// end loop over 'r'
4534
 
      for (unsigned int r = 0; r < 1; r++)
4535
 
      {
4536
 
        for (unsigned int s = 1; s < 2 - r; s++)
4537
 
        {
4538
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
4539
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4540
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
4541
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
4542
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4543
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4544
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
4545
 
        }// end loop over 's'
4546
 
      }// end loop over 'r'
4547
 
      for (unsigned int r = 0; r < 2; r++)
4548
 
      {
4549
 
        for (unsigned int s = 0; s < 2 - r; s++)
4550
 
        {
4551
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
4552
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4553
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
4554
 
        }// end loop over 's'
4555
 
      }// end loop over 'r'
4556
 
      for (unsigned int r = 0; r < 1; r++)
4557
 
      {
4558
 
        for (unsigned int s = 0; s < 1 - r; s++)
4559
 
        {
4560
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
4561
 
          {
4562
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
4563
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4564
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
4565
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
4566
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4567
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4568
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
4569
 
          }// end loop over 't'
4570
 
        }// end loop over 's'
4571
 
      }// end loop over 'r'
4572
 
      for (unsigned int r = 0; r < 3; r++)
4573
 
      {
4574
 
        for (unsigned int s = 0; s < 3 - r; s++)
4575
 
        {
4576
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
4577
 
          {
4578
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4579
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
4580
 
          }// end loop over 't'
4581
 
        }// end loop over 's'
4582
 
      }// end loop over 'r'
 
3415
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3416
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3417
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3418
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3419
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3420
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3421
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3422
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3423
      basisvalues[0] *= std::sqrt(0.75);
 
3424
      basisvalues[3] *= std::sqrt(1.25);
 
3425
      basisvalues[9] *= std::sqrt(1.75);
 
3426
      basisvalues[2] *= std::sqrt(2.5);
 
3427
      basisvalues[8] *= std::sqrt(3.5);
 
3428
      basisvalues[7] *= std::sqrt(5.25);
 
3429
      basisvalues[1] *= std::sqrt(7.5);
 
3430
      basisvalues[6] *= std::sqrt(10.5);
 
3431
      basisvalues[5] *= std::sqrt(15.75);
 
3432
      basisvalues[4] *= std::sqrt(26.25);
4583
3433
      
4584
3434
      // Table(s) of coefficients.
4585
3435
      static const double coefficients0[10] = \
4599
3449
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
4600
3450
      
4601
3451
      // Declare helper variables.
4602
 
      unsigned int rr = 0;
4603
 
      unsigned int ss = 0;
4604
 
      unsigned int tt = 0;
4605
 
      double tmp5 = 0.0;
4606
 
      double tmp6 = 0.0;
4607
 
      double tmp7 = 0.0;
4608
3452
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4609
3453
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
4610
3454
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
4614
3458
      // Compute basisvalues.
4615
3459
      basisvalues[0] = 1.0;
4616
3460
      basisvalues[1] = tmp0;
4617
 
      for (unsigned int r = 1; r < 2; r++)
4618
 
      {
4619
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
4620
 
        ss = r*(r + 1)*(r + 2)/6;
4621
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
4622
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
4623
 
      }// end loop over 'r'
4624
 
      for (unsigned int r = 0; r < 2; r++)
4625
 
      {
4626
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
4627
 
        ss = r*(r + 1)*(r + 2)/6;
4628
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
4629
 
      }// end loop over 'r'
4630
 
      for (unsigned int r = 0; r < 1; r++)
4631
 
      {
4632
 
        for (unsigned int s = 1; s < 2 - r; s++)
4633
 
        {
4634
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
4635
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4636
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
4637
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
4638
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4639
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4640
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
4641
 
        }// end loop over 's'
4642
 
      }// end loop over 'r'
4643
 
      for (unsigned int r = 0; r < 2; r++)
4644
 
      {
4645
 
        for (unsigned int s = 0; s < 2 - r; s++)
4646
 
        {
4647
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
4648
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4649
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
4650
 
        }// end loop over 's'
4651
 
      }// end loop over 'r'
4652
 
      for (unsigned int r = 0; r < 1; r++)
4653
 
      {
4654
 
        for (unsigned int s = 0; s < 1 - r; s++)
4655
 
        {
4656
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
4657
 
          {
4658
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
4659
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4660
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
4661
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
4662
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4663
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4664
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
4665
 
          }// end loop over 't'
4666
 
        }// end loop over 's'
4667
 
      }// end loop over 'r'
4668
 
      for (unsigned int r = 0; r < 3; r++)
4669
 
      {
4670
 
        for (unsigned int s = 0; s < 3 - r; s++)
4671
 
        {
4672
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
4673
 
          {
4674
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4675
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
4676
 
          }// end loop over 't'
4677
 
        }// end loop over 's'
4678
 
      }// end loop over 'r'
 
3461
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3462
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3463
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3464
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3465
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3466
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3467
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3468
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3469
      basisvalues[0] *= std::sqrt(0.75);
 
3470
      basisvalues[3] *= std::sqrt(1.25);
 
3471
      basisvalues[9] *= std::sqrt(1.75);
 
3472
      basisvalues[2] *= std::sqrt(2.5);
 
3473
      basisvalues[8] *= std::sqrt(3.5);
 
3474
      basisvalues[7] *= std::sqrt(5.25);
 
3475
      basisvalues[1] *= std::sqrt(7.5);
 
3476
      basisvalues[6] *= std::sqrt(10.5);
 
3477
      basisvalues[5] *= std::sqrt(15.75);
 
3478
      basisvalues[4] *= std::sqrt(26.25);
4679
3479
      
4680
3480
      // Table(s) of coefficients.
4681
3481
      static const double coefficients0[10] = \
4695
3495
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
4696
3496
      
4697
3497
      // Declare helper variables.
4698
 
      unsigned int rr = 0;
4699
 
      unsigned int ss = 0;
4700
 
      unsigned int tt = 0;
4701
 
      double tmp5 = 0.0;
4702
 
      double tmp6 = 0.0;
4703
 
      double tmp7 = 0.0;
4704
3498
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4705
3499
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
4706
3500
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
4710
3504
      // Compute basisvalues.
4711
3505
      basisvalues[0] = 1.0;
4712
3506
      basisvalues[1] = tmp0;
4713
 
      for (unsigned int r = 1; r < 2; r++)
4714
 
      {
4715
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
4716
 
        ss = r*(r + 1)*(r + 2)/6;
4717
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
4718
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
4719
 
      }// end loop over 'r'
4720
 
      for (unsigned int r = 0; r < 2; r++)
4721
 
      {
4722
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
4723
 
        ss = r*(r + 1)*(r + 2)/6;
4724
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
4725
 
      }// end loop over 'r'
4726
 
      for (unsigned int r = 0; r < 1; r++)
4727
 
      {
4728
 
        for (unsigned int s = 1; s < 2 - r; s++)
4729
 
        {
4730
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
4731
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4732
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
4733
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
4734
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4735
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4736
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
4737
 
        }// end loop over 's'
4738
 
      }// end loop over 'r'
4739
 
      for (unsigned int r = 0; r < 2; r++)
4740
 
      {
4741
 
        for (unsigned int s = 0; s < 2 - r; s++)
4742
 
        {
4743
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
4744
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4745
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
4746
 
        }// end loop over 's'
4747
 
      }// end loop over 'r'
4748
 
      for (unsigned int r = 0; r < 1; r++)
4749
 
      {
4750
 
        for (unsigned int s = 0; s < 1 - r; s++)
4751
 
        {
4752
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
4753
 
          {
4754
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
4755
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4756
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
4757
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
4758
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4759
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4760
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
4761
 
          }// end loop over 't'
4762
 
        }// end loop over 's'
4763
 
      }// end loop over 'r'
4764
 
      for (unsigned int r = 0; r < 3; r++)
4765
 
      {
4766
 
        for (unsigned int s = 0; s < 3 - r; s++)
4767
 
        {
4768
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
4769
 
          {
4770
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4771
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
4772
 
          }// end loop over 't'
4773
 
        }// end loop over 's'
4774
 
      }// end loop over 'r'
 
3507
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3508
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3509
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3510
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3511
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3512
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3513
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3514
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3515
      basisvalues[0] *= std::sqrt(0.75);
 
3516
      basisvalues[3] *= std::sqrt(1.25);
 
3517
      basisvalues[9] *= std::sqrt(1.75);
 
3518
      basisvalues[2] *= std::sqrt(2.5);
 
3519
      basisvalues[8] *= std::sqrt(3.5);
 
3520
      basisvalues[7] *= std::sqrt(5.25);
 
3521
      basisvalues[1] *= std::sqrt(7.5);
 
3522
      basisvalues[6] *= std::sqrt(10.5);
 
3523
      basisvalues[5] *= std::sqrt(15.75);
 
3524
      basisvalues[4] *= std::sqrt(26.25);
4775
3525
      
4776
3526
      // Table(s) of coefficients.
4777
3527
      static const double coefficients0[10] = \
4791
3541
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
4792
3542
      
4793
3543
      // Declare helper variables.
4794
 
      unsigned int rr = 0;
4795
 
      unsigned int ss = 0;
4796
 
      unsigned int tt = 0;
4797
 
      double tmp5 = 0.0;
4798
 
      double tmp6 = 0.0;
4799
 
      double tmp7 = 0.0;
4800
3544
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4801
3545
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
4802
3546
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
4806
3550
      // Compute basisvalues.
4807
3551
      basisvalues[0] = 1.0;
4808
3552
      basisvalues[1] = tmp0;
4809
 
      for (unsigned int r = 1; r < 2; r++)
4810
 
      {
4811
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
4812
 
        ss = r*(r + 1)*(r + 2)/6;
4813
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
4814
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
4815
 
      }// end loop over 'r'
4816
 
      for (unsigned int r = 0; r < 2; r++)
4817
 
      {
4818
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
4819
 
        ss = r*(r + 1)*(r + 2)/6;
4820
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
4821
 
      }// end loop over 'r'
4822
 
      for (unsigned int r = 0; r < 1; r++)
4823
 
      {
4824
 
        for (unsigned int s = 1; s < 2 - r; s++)
4825
 
        {
4826
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
4827
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4828
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
4829
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
4830
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4831
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4832
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
4833
 
        }// end loop over 's'
4834
 
      }// end loop over 'r'
4835
 
      for (unsigned int r = 0; r < 2; r++)
4836
 
      {
4837
 
        for (unsigned int s = 0; s < 2 - r; s++)
4838
 
        {
4839
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
4840
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4841
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
4842
 
        }// end loop over 's'
4843
 
      }// end loop over 'r'
4844
 
      for (unsigned int r = 0; r < 1; r++)
4845
 
      {
4846
 
        for (unsigned int s = 0; s < 1 - r; s++)
4847
 
        {
4848
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
4849
 
          {
4850
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
4851
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4852
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
4853
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
4854
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4855
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4856
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
4857
 
          }// end loop over 't'
4858
 
        }// end loop over 's'
4859
 
      }// end loop over 'r'
4860
 
      for (unsigned int r = 0; r < 3; r++)
4861
 
      {
4862
 
        for (unsigned int s = 0; s < 3 - r; s++)
4863
 
        {
4864
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
4865
 
          {
4866
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4867
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
4868
 
          }// end loop over 't'
4869
 
        }// end loop over 's'
4870
 
      }// end loop over 'r'
 
3553
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3554
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3555
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3556
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3557
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3558
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3559
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3560
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3561
      basisvalues[0] *= std::sqrt(0.75);
 
3562
      basisvalues[3] *= std::sqrt(1.25);
 
3563
      basisvalues[9] *= std::sqrt(1.75);
 
3564
      basisvalues[2] *= std::sqrt(2.5);
 
3565
      basisvalues[8] *= std::sqrt(3.5);
 
3566
      basisvalues[7] *= std::sqrt(5.25);
 
3567
      basisvalues[1] *= std::sqrt(7.5);
 
3568
      basisvalues[6] *= std::sqrt(10.5);
 
3569
      basisvalues[5] *= std::sqrt(15.75);
 
3570
      basisvalues[4] *= std::sqrt(26.25);
4871
3571
      
4872
3572
      // Table(s) of coefficients.
4873
3573
      static const double coefficients0[10] = \
4887
3587
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
4888
3588
      
4889
3589
      // Declare helper variables.
4890
 
      unsigned int rr = 0;
4891
 
      unsigned int ss = 0;
4892
 
      unsigned int tt = 0;
4893
 
      double tmp5 = 0.0;
4894
 
      double tmp6 = 0.0;
4895
 
      double tmp7 = 0.0;
4896
3590
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4897
3591
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
4898
3592
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
4902
3596
      // Compute basisvalues.
4903
3597
      basisvalues[0] = 1.0;
4904
3598
      basisvalues[1] = tmp0;
4905
 
      for (unsigned int r = 1; r < 2; r++)
4906
 
      {
4907
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
4908
 
        ss = r*(r + 1)*(r + 2)/6;
4909
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
4910
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
4911
 
      }// end loop over 'r'
4912
 
      for (unsigned int r = 0; r < 2; r++)
4913
 
      {
4914
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
4915
 
        ss = r*(r + 1)*(r + 2)/6;
4916
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
4917
 
      }// end loop over 'r'
4918
 
      for (unsigned int r = 0; r < 1; r++)
4919
 
      {
4920
 
        for (unsigned int s = 1; s < 2 - r; s++)
4921
 
        {
4922
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
4923
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4924
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
4925
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
4926
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4927
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
4928
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
4929
 
        }// end loop over 's'
4930
 
      }// end loop over 'r'
4931
 
      for (unsigned int r = 0; r < 2; r++)
4932
 
      {
4933
 
        for (unsigned int s = 0; s < 2 - r; s++)
4934
 
        {
4935
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
4936
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4937
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
4938
 
        }// end loop over 's'
4939
 
      }// end loop over 'r'
4940
 
      for (unsigned int r = 0; r < 1; r++)
4941
 
      {
4942
 
        for (unsigned int s = 0; s < 1 - r; s++)
4943
 
        {
4944
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
4945
 
          {
4946
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
4947
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4948
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
4949
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
4950
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4951
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
4952
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
4953
 
          }// end loop over 't'
4954
 
        }// end loop over 's'
4955
 
      }// end loop over 'r'
4956
 
      for (unsigned int r = 0; r < 3; r++)
4957
 
      {
4958
 
        for (unsigned int s = 0; s < 3 - r; s++)
4959
 
        {
4960
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
4961
 
          {
4962
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4963
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
4964
 
          }// end loop over 't'
4965
 
        }// end loop over 's'
4966
 
      }// end loop over 'r'
 
3599
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3600
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3601
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3602
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3603
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3604
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3605
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3606
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3607
      basisvalues[0] *= std::sqrt(0.75);
 
3608
      basisvalues[3] *= std::sqrt(1.25);
 
3609
      basisvalues[9] *= std::sqrt(1.75);
 
3610
      basisvalues[2] *= std::sqrt(2.5);
 
3611
      basisvalues[8] *= std::sqrt(3.5);
 
3612
      basisvalues[7] *= std::sqrt(5.25);
 
3613
      basisvalues[1] *= std::sqrt(7.5);
 
3614
      basisvalues[6] *= std::sqrt(10.5);
 
3615
      basisvalues[5] *= std::sqrt(15.75);
 
3616
      basisvalues[4] *= std::sqrt(26.25);
4967
3617
      
4968
3618
      // Table(s) of coefficients.
4969
3619
      static const double coefficients0[10] = \
4983
3633
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
4984
3634
      
4985
3635
      // Declare helper variables.
4986
 
      unsigned int rr = 0;
4987
 
      unsigned int ss = 0;
4988
 
      unsigned int tt = 0;
4989
 
      double tmp5 = 0.0;
4990
 
      double tmp6 = 0.0;
4991
 
      double tmp7 = 0.0;
4992
3636
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4993
3637
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
4994
3638
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
4998
3642
      // Compute basisvalues.
4999
3643
      basisvalues[0] = 1.0;
5000
3644
      basisvalues[1] = tmp0;
5001
 
      for (unsigned int r = 1; r < 2; r++)
5002
 
      {
5003
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5004
 
        ss = r*(r + 1)*(r + 2)/6;
5005
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5006
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5007
 
      }// end loop over 'r'
5008
 
      for (unsigned int r = 0; r < 2; r++)
5009
 
      {
5010
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5011
 
        ss = r*(r + 1)*(r + 2)/6;
5012
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5013
 
      }// end loop over 'r'
5014
 
      for (unsigned int r = 0; r < 1; r++)
5015
 
      {
5016
 
        for (unsigned int s = 1; s < 2 - r; s++)
5017
 
        {
5018
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5019
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5020
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5021
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5022
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5023
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5024
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5025
 
        }// end loop over 's'
5026
 
      }// end loop over 'r'
5027
 
      for (unsigned int r = 0; r < 2; r++)
5028
 
      {
5029
 
        for (unsigned int s = 0; s < 2 - r; s++)
5030
 
        {
5031
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5032
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5033
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5034
 
        }// end loop over 's'
5035
 
      }// end loop over 'r'
5036
 
      for (unsigned int r = 0; r < 1; r++)
5037
 
      {
5038
 
        for (unsigned int s = 0; s < 1 - r; s++)
5039
 
        {
5040
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
5041
 
          {
5042
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
5043
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5044
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
5045
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
5046
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5047
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5048
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
5049
 
          }// end loop over 't'
5050
 
        }// end loop over 's'
5051
 
      }// end loop over 'r'
5052
 
      for (unsigned int r = 0; r < 3; r++)
5053
 
      {
5054
 
        for (unsigned int s = 0; s < 3 - r; s++)
5055
 
        {
5056
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
5057
 
          {
5058
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5059
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
5060
 
          }// end loop over 't'
5061
 
        }// end loop over 's'
5062
 
      }// end loop over 'r'
 
3645
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3646
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3647
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3648
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3649
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3650
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3651
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3652
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3653
      basisvalues[0] *= std::sqrt(0.75);
 
3654
      basisvalues[3] *= std::sqrt(1.25);
 
3655
      basisvalues[9] *= std::sqrt(1.75);
 
3656
      basisvalues[2] *= std::sqrt(2.5);
 
3657
      basisvalues[8] *= std::sqrt(3.5);
 
3658
      basisvalues[7] *= std::sqrt(5.25);
 
3659
      basisvalues[1] *= std::sqrt(7.5);
 
3660
      basisvalues[6] *= std::sqrt(10.5);
 
3661
      basisvalues[5] *= std::sqrt(15.75);
 
3662
      basisvalues[4] *= std::sqrt(26.25);
5063
3663
      
5064
3664
      // Table(s) of coefficients.
5065
3665
      static const double coefficients0[10] = \
5079
3679
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
5080
3680
      
5081
3681
      // Declare helper variables.
5082
 
      unsigned int rr = 0;
5083
 
      unsigned int ss = 0;
5084
 
      unsigned int tt = 0;
5085
 
      double tmp5 = 0.0;
5086
 
      double tmp6 = 0.0;
5087
 
      double tmp7 = 0.0;
5088
3682
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
5089
3683
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
5090
3684
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
5094
3688
      // Compute basisvalues.
5095
3689
      basisvalues[0] = 1.0;
5096
3690
      basisvalues[1] = tmp0;
5097
 
      for (unsigned int r = 1; r < 2; r++)
5098
 
      {
5099
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5100
 
        ss = r*(r + 1)*(r + 2)/6;
5101
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5102
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5103
 
      }// end loop over 'r'
5104
 
      for (unsigned int r = 0; r < 2; r++)
5105
 
      {
5106
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5107
 
        ss = r*(r + 1)*(r + 2)/6;
5108
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5109
 
      }// end loop over 'r'
5110
 
      for (unsigned int r = 0; r < 1; r++)
5111
 
      {
5112
 
        for (unsigned int s = 1; s < 2 - r; s++)
5113
 
        {
5114
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5115
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5116
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5117
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5118
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5119
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5120
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5121
 
        }// end loop over 's'
5122
 
      }// end loop over 'r'
5123
 
      for (unsigned int r = 0; r < 2; r++)
5124
 
      {
5125
 
        for (unsigned int s = 0; s < 2 - r; s++)
5126
 
        {
5127
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5128
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5129
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5130
 
        }// end loop over 's'
5131
 
      }// end loop over 'r'
5132
 
      for (unsigned int r = 0; r < 1; r++)
5133
 
      {
5134
 
        for (unsigned int s = 0; s < 1 - r; s++)
5135
 
        {
5136
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
5137
 
          {
5138
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
5139
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5140
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
5141
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
5142
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5143
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5144
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
5145
 
          }// end loop over 't'
5146
 
        }// end loop over 's'
5147
 
      }// end loop over 'r'
5148
 
      for (unsigned int r = 0; r < 3; r++)
5149
 
      {
5150
 
        for (unsigned int s = 0; s < 3 - r; s++)
5151
 
        {
5152
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
5153
 
          {
5154
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5155
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
5156
 
          }// end loop over 't'
5157
 
        }// end loop over 's'
5158
 
      }// end loop over 'r'
 
3691
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3692
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3693
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3694
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3695
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3696
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3697
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3698
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3699
      basisvalues[0] *= std::sqrt(0.75);
 
3700
      basisvalues[3] *= std::sqrt(1.25);
 
3701
      basisvalues[9] *= std::sqrt(1.75);
 
3702
      basisvalues[2] *= std::sqrt(2.5);
 
3703
      basisvalues[8] *= std::sqrt(3.5);
 
3704
      basisvalues[7] *= std::sqrt(5.25);
 
3705
      basisvalues[1] *= std::sqrt(7.5);
 
3706
      basisvalues[6] *= std::sqrt(10.5);
 
3707
      basisvalues[5] *= std::sqrt(15.75);
 
3708
      basisvalues[4] *= std::sqrt(26.25);
5159
3709
      
5160
3710
      // Table(s) of coefficients.
5161
3711
      static const double coefficients0[10] = \
5175
3725
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
5176
3726
      
5177
3727
      // Declare helper variables.
5178
 
      unsigned int rr = 0;
5179
 
      unsigned int ss = 0;
5180
 
      unsigned int tt = 0;
5181
 
      double tmp5 = 0.0;
5182
 
      double tmp6 = 0.0;
5183
 
      double tmp7 = 0.0;
5184
3728
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
5185
3729
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
5186
3730
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
5190
3734
      // Compute basisvalues.
5191
3735
      basisvalues[0] = 1.0;
5192
3736
      basisvalues[1] = tmp0;
5193
 
      for (unsigned int r = 1; r < 2; r++)
5194
 
      {
5195
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5196
 
        ss = r*(r + 1)*(r + 2)/6;
5197
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5198
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5199
 
      }// end loop over 'r'
5200
 
      for (unsigned int r = 0; r < 2; r++)
5201
 
      {
5202
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5203
 
        ss = r*(r + 1)*(r + 2)/6;
5204
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5205
 
      }// end loop over 'r'
5206
 
      for (unsigned int r = 0; r < 1; r++)
5207
 
      {
5208
 
        for (unsigned int s = 1; s < 2 - r; s++)
5209
 
        {
5210
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5211
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5212
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5213
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5214
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5215
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5216
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5217
 
        }// end loop over 's'
5218
 
      }// end loop over 'r'
5219
 
      for (unsigned int r = 0; r < 2; r++)
5220
 
      {
5221
 
        for (unsigned int s = 0; s < 2 - r; s++)
5222
 
        {
5223
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5224
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5225
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5226
 
        }// end loop over 's'
5227
 
      }// end loop over 'r'
5228
 
      for (unsigned int r = 0; r < 1; r++)
5229
 
      {
5230
 
        for (unsigned int s = 0; s < 1 - r; s++)
5231
 
        {
5232
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
5233
 
          {
5234
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
5235
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5236
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
5237
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
5238
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5239
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5240
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
5241
 
          }// end loop over 't'
5242
 
        }// end loop over 's'
5243
 
      }// end loop over 'r'
5244
 
      for (unsigned int r = 0; r < 3; r++)
5245
 
      {
5246
 
        for (unsigned int s = 0; s < 3 - r; s++)
5247
 
        {
5248
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
5249
 
          {
5250
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5251
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
5252
 
          }// end loop over 't'
5253
 
        }// end loop over 's'
5254
 
      }// end loop over 'r'
 
3737
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3738
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3739
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3740
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3741
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3742
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3743
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3744
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3745
      basisvalues[0] *= std::sqrt(0.75);
 
3746
      basisvalues[3] *= std::sqrt(1.25);
 
3747
      basisvalues[9] *= std::sqrt(1.75);
 
3748
      basisvalues[2] *= std::sqrt(2.5);
 
3749
      basisvalues[8] *= std::sqrt(3.5);
 
3750
      basisvalues[7] *= std::sqrt(5.25);
 
3751
      basisvalues[1] *= std::sqrt(7.5);
 
3752
      basisvalues[6] *= std::sqrt(10.5);
 
3753
      basisvalues[5] *= std::sqrt(15.75);
 
3754
      basisvalues[4] *= std::sqrt(26.25);
5255
3755
      
5256
3756
      // Table(s) of coefficients.
5257
3757
      static const double coefficients0[10] = \
5271
3771
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
5272
3772
      
5273
3773
      // Declare helper variables.
5274
 
      unsigned int rr = 0;
5275
 
      unsigned int ss = 0;
5276
 
      unsigned int tt = 0;
5277
 
      double tmp5 = 0.0;
5278
 
      double tmp6 = 0.0;
5279
 
      double tmp7 = 0.0;
5280
3774
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
5281
3775
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
5282
3776
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
5286
3780
      // Compute basisvalues.
5287
3781
      basisvalues[0] = 1.0;
5288
3782
      basisvalues[1] = tmp0;
5289
 
      for (unsigned int r = 1; r < 2; r++)
5290
 
      {
5291
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5292
 
        ss = r*(r + 1)*(r + 2)/6;
5293
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5294
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5295
 
      }// end loop over 'r'
5296
 
      for (unsigned int r = 0; r < 2; r++)
5297
 
      {
5298
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5299
 
        ss = r*(r + 1)*(r + 2)/6;
5300
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5301
 
      }// end loop over 'r'
5302
 
      for (unsigned int r = 0; r < 1; r++)
5303
 
      {
5304
 
        for (unsigned int s = 1; s < 2 - r; s++)
5305
 
        {
5306
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5307
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5308
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5309
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5310
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5311
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5312
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5313
 
        }// end loop over 's'
5314
 
      }// end loop over 'r'
5315
 
      for (unsigned int r = 0; r < 2; r++)
5316
 
      {
5317
 
        for (unsigned int s = 0; s < 2 - r; s++)
5318
 
        {
5319
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5320
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5321
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5322
 
        }// end loop over 's'
5323
 
      }// end loop over 'r'
5324
 
      for (unsigned int r = 0; r < 1; r++)
5325
 
      {
5326
 
        for (unsigned int s = 0; s < 1 - r; s++)
5327
 
        {
5328
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
5329
 
          {
5330
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
5331
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5332
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
5333
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
5334
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5335
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5336
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
5337
 
          }// end loop over 't'
5338
 
        }// end loop over 's'
5339
 
      }// end loop over 'r'
5340
 
      for (unsigned int r = 0; r < 3; r++)
5341
 
      {
5342
 
        for (unsigned int s = 0; s < 3 - r; s++)
5343
 
        {
5344
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
5345
 
          {
5346
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5347
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
5348
 
          }// end loop over 't'
5349
 
        }// end loop over 's'
5350
 
      }// end loop over 'r'
 
3783
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3784
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3785
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3786
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3787
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3788
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3789
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3790
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3791
      basisvalues[0] *= std::sqrt(0.75);
 
3792
      basisvalues[3] *= std::sqrt(1.25);
 
3793
      basisvalues[9] *= std::sqrt(1.75);
 
3794
      basisvalues[2] *= std::sqrt(2.5);
 
3795
      basisvalues[8] *= std::sqrt(3.5);
 
3796
      basisvalues[7] *= std::sqrt(5.25);
 
3797
      basisvalues[1] *= std::sqrt(7.5);
 
3798
      basisvalues[6] *= std::sqrt(10.5);
 
3799
      basisvalues[5] *= std::sqrt(15.75);
 
3800
      basisvalues[4] *= std::sqrt(26.25);
5351
3801
      
5352
3802
      // Table(s) of coefficients.
5353
3803
      static const double coefficients0[10] = \
5367
3817
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
5368
3818
      
5369
3819
      // Declare helper variables.
5370
 
      unsigned int rr = 0;
5371
 
      unsigned int ss = 0;
5372
 
      unsigned int tt = 0;
5373
 
      double tmp5 = 0.0;
5374
 
      double tmp6 = 0.0;
5375
 
      double tmp7 = 0.0;
5376
3820
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
5377
3821
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
5378
3822
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
5382
3826
      // Compute basisvalues.
5383
3827
      basisvalues[0] = 1.0;
5384
3828
      basisvalues[1] = tmp0;
5385
 
      for (unsigned int r = 1; r < 2; r++)
5386
 
      {
5387
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5388
 
        ss = r*(r + 1)*(r + 2)/6;
5389
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5390
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5391
 
      }// end loop over 'r'
5392
 
      for (unsigned int r = 0; r < 2; r++)
5393
 
      {
5394
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5395
 
        ss = r*(r + 1)*(r + 2)/6;
5396
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5397
 
      }// end loop over 'r'
5398
 
      for (unsigned int r = 0; r < 1; r++)
5399
 
      {
5400
 
        for (unsigned int s = 1; s < 2 - r; s++)
5401
 
        {
5402
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5403
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5404
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5405
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5406
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5407
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5408
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5409
 
        }// end loop over 's'
5410
 
      }// end loop over 'r'
5411
 
      for (unsigned int r = 0; r < 2; r++)
5412
 
      {
5413
 
        for (unsigned int s = 0; s < 2 - r; s++)
5414
 
        {
5415
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5416
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5417
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5418
 
        }// end loop over 's'
5419
 
      }// end loop over 'r'
5420
 
      for (unsigned int r = 0; r < 1; r++)
5421
 
      {
5422
 
        for (unsigned int s = 0; s < 1 - r; s++)
5423
 
        {
5424
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
5425
 
          {
5426
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
5427
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5428
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
5429
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
5430
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5431
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5432
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
5433
 
          }// end loop over 't'
5434
 
        }// end loop over 's'
5435
 
      }// end loop over 'r'
5436
 
      for (unsigned int r = 0; r < 3; r++)
5437
 
      {
5438
 
        for (unsigned int s = 0; s < 3 - r; s++)
5439
 
        {
5440
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
5441
 
          {
5442
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5443
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
5444
 
          }// end loop over 't'
5445
 
        }// end loop over 's'
5446
 
      }// end loop over 'r'
 
3829
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3830
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3831
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3832
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3833
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3834
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3835
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3836
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3837
      basisvalues[0] *= std::sqrt(0.75);
 
3838
      basisvalues[3] *= std::sqrt(1.25);
 
3839
      basisvalues[9] *= std::sqrt(1.75);
 
3840
      basisvalues[2] *= std::sqrt(2.5);
 
3841
      basisvalues[8] *= std::sqrt(3.5);
 
3842
      basisvalues[7] *= std::sqrt(5.25);
 
3843
      basisvalues[1] *= std::sqrt(7.5);
 
3844
      basisvalues[6] *= std::sqrt(10.5);
 
3845
      basisvalues[5] *= std::sqrt(15.75);
 
3846
      basisvalues[4] *= std::sqrt(26.25);
5447
3847
      
5448
3848
      // Table(s) of coefficients.
5449
3849
      static const double coefficients0[10] = \
5463
3863
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
5464
3864
      
5465
3865
      // Declare helper variables.
5466
 
      unsigned int rr = 0;
5467
 
      unsigned int ss = 0;
5468
 
      unsigned int tt = 0;
5469
 
      double tmp5 = 0.0;
5470
 
      double tmp6 = 0.0;
5471
 
      double tmp7 = 0.0;
5472
3866
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
5473
3867
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
5474
3868
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
5478
3872
      // Compute basisvalues.
5479
3873
      basisvalues[0] = 1.0;
5480
3874
      basisvalues[1] = tmp0;
5481
 
      for (unsigned int r = 1; r < 2; r++)
5482
 
      {
5483
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5484
 
        ss = r*(r + 1)*(r + 2)/6;
5485
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5486
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5487
 
      }// end loop over 'r'
5488
 
      for (unsigned int r = 0; r < 2; r++)
5489
 
      {
5490
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5491
 
        ss = r*(r + 1)*(r + 2)/6;
5492
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5493
 
      }// end loop over 'r'
5494
 
      for (unsigned int r = 0; r < 1; r++)
5495
 
      {
5496
 
        for (unsigned int s = 1; s < 2 - r; s++)
5497
 
        {
5498
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5499
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5500
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5501
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5502
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5503
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5504
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5505
 
        }// end loop over 's'
5506
 
      }// end loop over 'r'
5507
 
      for (unsigned int r = 0; r < 2; r++)
5508
 
      {
5509
 
        for (unsigned int s = 0; s < 2 - r; s++)
5510
 
        {
5511
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5512
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5513
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5514
 
        }// end loop over 's'
5515
 
      }// end loop over 'r'
5516
 
      for (unsigned int r = 0; r < 1; r++)
5517
 
      {
5518
 
        for (unsigned int s = 0; s < 1 - r; s++)
5519
 
        {
5520
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
5521
 
          {
5522
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
5523
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5524
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
5525
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
5526
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5527
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5528
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
5529
 
          }// end loop over 't'
5530
 
        }// end loop over 's'
5531
 
      }// end loop over 'r'
5532
 
      for (unsigned int r = 0; r < 3; r++)
5533
 
      {
5534
 
        for (unsigned int s = 0; s < 3 - r; s++)
5535
 
        {
5536
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
5537
 
          {
5538
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5539
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
5540
 
          }// end loop over 't'
5541
 
        }// end loop over 's'
5542
 
      }// end loop over 'r'
 
3875
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3876
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3877
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3878
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3879
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3880
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3881
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3882
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3883
      basisvalues[0] *= std::sqrt(0.75);
 
3884
      basisvalues[3] *= std::sqrt(1.25);
 
3885
      basisvalues[9] *= std::sqrt(1.75);
 
3886
      basisvalues[2] *= std::sqrt(2.5);
 
3887
      basisvalues[8] *= std::sqrt(3.5);
 
3888
      basisvalues[7] *= std::sqrt(5.25);
 
3889
      basisvalues[1] *= std::sqrt(7.5);
 
3890
      basisvalues[6] *= std::sqrt(10.5);
 
3891
      basisvalues[5] *= std::sqrt(15.75);
 
3892
      basisvalues[4] *= std::sqrt(26.25);
5543
3893
      
5544
3894
      // Table(s) of coefficients.
5545
3895
      static const double coefficients0[10] = \
5559
3909
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
5560
3910
      
5561
3911
      // Declare helper variables.
5562
 
      unsigned int rr = 0;
5563
 
      unsigned int ss = 0;
5564
 
      unsigned int tt = 0;
5565
 
      double tmp5 = 0.0;
5566
 
      double tmp6 = 0.0;
5567
 
      double tmp7 = 0.0;
5568
3912
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
5569
3913
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
5570
3914
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
5574
3918
      // Compute basisvalues.
5575
3919
      basisvalues[0] = 1.0;
5576
3920
      basisvalues[1] = tmp0;
5577
 
      for (unsigned int r = 1; r < 2; r++)
5578
 
      {
5579
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5580
 
        ss = r*(r + 1)*(r + 2)/6;
5581
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5582
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5583
 
      }// end loop over 'r'
5584
 
      for (unsigned int r = 0; r < 2; r++)
5585
 
      {
5586
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5587
 
        ss = r*(r + 1)*(r + 2)/6;
5588
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5589
 
      }// end loop over 'r'
5590
 
      for (unsigned int r = 0; r < 1; r++)
5591
 
      {
5592
 
        for (unsigned int s = 1; s < 2 - r; s++)
5593
 
        {
5594
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5595
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5596
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5597
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5598
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5599
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5600
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5601
 
        }// end loop over 's'
5602
 
      }// end loop over 'r'
5603
 
      for (unsigned int r = 0; r < 2; r++)
5604
 
      {
5605
 
        for (unsigned int s = 0; s < 2 - r; s++)
5606
 
        {
5607
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5608
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5609
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5610
 
        }// end loop over 's'
5611
 
      }// end loop over 'r'
5612
 
      for (unsigned int r = 0; r < 1; r++)
5613
 
      {
5614
 
        for (unsigned int s = 0; s < 1 - r; s++)
5615
 
        {
5616
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
5617
 
          {
5618
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
5619
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5620
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
5621
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
5622
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5623
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5624
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
5625
 
          }// end loop over 't'
5626
 
        }// end loop over 's'
5627
 
      }// end loop over 'r'
5628
 
      for (unsigned int r = 0; r < 3; r++)
5629
 
      {
5630
 
        for (unsigned int s = 0; s < 3 - r; s++)
5631
 
        {
5632
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
5633
 
          {
5634
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5635
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
5636
 
          }// end loop over 't'
5637
 
        }// end loop over 's'
5638
 
      }// end loop over 'r'
 
3921
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3922
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3923
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3924
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3925
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3926
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3927
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3928
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3929
      basisvalues[0] *= std::sqrt(0.75);
 
3930
      basisvalues[3] *= std::sqrt(1.25);
 
3931
      basisvalues[9] *= std::sqrt(1.75);
 
3932
      basisvalues[2] *= std::sqrt(2.5);
 
3933
      basisvalues[8] *= std::sqrt(3.5);
 
3934
      basisvalues[7] *= std::sqrt(5.25);
 
3935
      basisvalues[1] *= std::sqrt(7.5);
 
3936
      basisvalues[6] *= std::sqrt(10.5);
 
3937
      basisvalues[5] *= std::sqrt(15.75);
 
3938
      basisvalues[4] *= std::sqrt(26.25);
5639
3939
      
5640
3940
      // Table(s) of coefficients.
5641
3941
      static const double coefficients0[10] = \
5655
3955
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
5656
3956
      
5657
3957
      // Declare helper variables.
5658
 
      unsigned int rr = 0;
5659
 
      unsigned int ss = 0;
5660
 
      unsigned int tt = 0;
5661
 
      double tmp5 = 0.0;
5662
 
      double tmp6 = 0.0;
5663
 
      double tmp7 = 0.0;
5664
3958
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
5665
3959
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
5666
3960
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
5670
3964
      // Compute basisvalues.
5671
3965
      basisvalues[0] = 1.0;
5672
3966
      basisvalues[1] = tmp0;
5673
 
      for (unsigned int r = 1; r < 2; r++)
5674
 
      {
5675
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5676
 
        ss = r*(r + 1)*(r + 2)/6;
5677
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5678
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5679
 
      }// end loop over 'r'
5680
 
      for (unsigned int r = 0; r < 2; r++)
5681
 
      {
5682
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5683
 
        ss = r*(r + 1)*(r + 2)/6;
5684
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5685
 
      }// end loop over 'r'
5686
 
      for (unsigned int r = 0; r < 1; r++)
5687
 
      {
5688
 
        for (unsigned int s = 1; s < 2 - r; s++)
5689
 
        {
5690
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5691
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5692
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5693
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5694
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5695
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5696
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5697
 
        }// end loop over 's'
5698
 
      }// end loop over 'r'
5699
 
      for (unsigned int r = 0; r < 2; r++)
5700
 
      {
5701
 
        for (unsigned int s = 0; s < 2 - r; s++)
5702
 
        {
5703
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5704
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5705
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5706
 
        }// end loop over 's'
5707
 
      }// end loop over 'r'
5708
 
      for (unsigned int r = 0; r < 1; r++)
5709
 
      {
5710
 
        for (unsigned int s = 0; s < 1 - r; s++)
5711
 
        {
5712
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
5713
 
          {
5714
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
5715
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5716
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
5717
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
5718
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5719
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5720
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
5721
 
          }// end loop over 't'
5722
 
        }// end loop over 's'
5723
 
      }// end loop over 'r'
5724
 
      for (unsigned int r = 0; r < 3; r++)
5725
 
      {
5726
 
        for (unsigned int s = 0; s < 3 - r; s++)
5727
 
        {
5728
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
5729
 
          {
5730
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5731
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
5732
 
          }// end loop over 't'
5733
 
        }// end loop over 's'
5734
 
      }// end loop over 'r'
 
3967
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
3968
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3969
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
3970
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
3971
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3972
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
3973
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
3974
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
3975
      basisvalues[0] *= std::sqrt(0.75);
 
3976
      basisvalues[3] *= std::sqrt(1.25);
 
3977
      basisvalues[9] *= std::sqrt(1.75);
 
3978
      basisvalues[2] *= std::sqrt(2.5);
 
3979
      basisvalues[8] *= std::sqrt(3.5);
 
3980
      basisvalues[7] *= std::sqrt(5.25);
 
3981
      basisvalues[1] *= std::sqrt(7.5);
 
3982
      basisvalues[6] *= std::sqrt(10.5);
 
3983
      basisvalues[5] *= std::sqrt(15.75);
 
3984
      basisvalues[4] *= std::sqrt(26.25);
5735
3985
      
5736
3986
      // Table(s) of coefficients.
5737
3987
      static const double coefficients0[10] = \
5751
4001
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
5752
4002
      
5753
4003
      // Declare helper variables.
5754
 
      unsigned int rr = 0;
5755
 
      unsigned int ss = 0;
5756
 
      unsigned int tt = 0;
5757
 
      double tmp5 = 0.0;
5758
 
      double tmp6 = 0.0;
5759
 
      double tmp7 = 0.0;
5760
4004
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
5761
4005
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
5762
4006
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
5766
4010
      // Compute basisvalues.
5767
4011
      basisvalues[0] = 1.0;
5768
4012
      basisvalues[1] = tmp0;
5769
 
      for (unsigned int r = 1; r < 2; r++)
5770
 
      {
5771
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5772
 
        ss = r*(r + 1)*(r + 2)/6;
5773
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5774
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5775
 
      }// end loop over 'r'
5776
 
      for (unsigned int r = 0; r < 2; r++)
5777
 
      {
5778
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5779
 
        ss = r*(r + 1)*(r + 2)/6;
5780
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5781
 
      }// end loop over 'r'
5782
 
      for (unsigned int r = 0; r < 1; r++)
5783
 
      {
5784
 
        for (unsigned int s = 1; s < 2 - r; s++)
5785
 
        {
5786
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5787
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5788
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5789
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5790
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5791
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5792
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5793
 
        }// end loop over 's'
5794
 
      }// end loop over 'r'
5795
 
      for (unsigned int r = 0; r < 2; r++)
5796
 
      {
5797
 
        for (unsigned int s = 0; s < 2 - r; s++)
5798
 
        {
5799
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5800
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5801
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5802
 
        }// end loop over 's'
5803
 
      }// end loop over 'r'
5804
 
      for (unsigned int r = 0; r < 1; r++)
5805
 
      {
5806
 
        for (unsigned int s = 0; s < 1 - r; s++)
5807
 
        {
5808
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
5809
 
          {
5810
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
5811
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5812
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
5813
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
5814
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5815
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5816
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
5817
 
          }// end loop over 't'
5818
 
        }// end loop over 's'
5819
 
      }// end loop over 'r'
5820
 
      for (unsigned int r = 0; r < 3; r++)
5821
 
      {
5822
 
        for (unsigned int s = 0; s < 3 - r; s++)
5823
 
        {
5824
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
5825
 
          {
5826
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5827
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
5828
 
          }// end loop over 't'
5829
 
        }// end loop over 's'
5830
 
      }// end loop over 'r'
 
4013
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4014
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4015
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4016
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4017
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4018
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4019
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4020
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4021
      basisvalues[0] *= std::sqrt(0.75);
 
4022
      basisvalues[3] *= std::sqrt(1.25);
 
4023
      basisvalues[9] *= std::sqrt(1.75);
 
4024
      basisvalues[2] *= std::sqrt(2.5);
 
4025
      basisvalues[8] *= std::sqrt(3.5);
 
4026
      basisvalues[7] *= std::sqrt(5.25);
 
4027
      basisvalues[1] *= std::sqrt(7.5);
 
4028
      basisvalues[6] *= std::sqrt(10.5);
 
4029
      basisvalues[5] *= std::sqrt(15.75);
 
4030
      basisvalues[4] *= std::sqrt(26.25);
5831
4031
      
5832
4032
      // Table(s) of coefficients.
5833
4033
      static const double coefficients0[10] = \
5847
4047
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
5848
4048
      
5849
4049
      // Declare helper variables.
5850
 
      unsigned int rr = 0;
5851
 
      unsigned int ss = 0;
5852
 
      unsigned int tt = 0;
5853
 
      double tmp5 = 0.0;
5854
 
      double tmp6 = 0.0;
5855
 
      double tmp7 = 0.0;
5856
4050
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
5857
4051
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
5858
4052
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
5862
4056
      // Compute basisvalues.
5863
4057
      basisvalues[0] = 1.0;
5864
4058
      basisvalues[1] = tmp0;
5865
 
      for (unsigned int r = 1; r < 2; r++)
5866
 
      {
5867
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5868
 
        ss = r*(r + 1)*(r + 2)/6;
5869
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5870
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5871
 
      }// end loop over 'r'
5872
 
      for (unsigned int r = 0; r < 2; r++)
5873
 
      {
5874
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5875
 
        ss = r*(r + 1)*(r + 2)/6;
5876
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5877
 
      }// end loop over 'r'
5878
 
      for (unsigned int r = 0; r < 1; r++)
5879
 
      {
5880
 
        for (unsigned int s = 1; s < 2 - r; s++)
5881
 
        {
5882
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5883
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5884
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5885
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5886
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5887
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5888
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5889
 
        }// end loop over 's'
5890
 
      }// end loop over 'r'
5891
 
      for (unsigned int r = 0; r < 2; r++)
5892
 
      {
5893
 
        for (unsigned int s = 0; s < 2 - r; s++)
5894
 
        {
5895
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5896
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5897
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5898
 
        }// end loop over 's'
5899
 
      }// end loop over 'r'
5900
 
      for (unsigned int r = 0; r < 1; r++)
5901
 
      {
5902
 
        for (unsigned int s = 0; s < 1 - r; s++)
5903
 
        {
5904
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
5905
 
          {
5906
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
5907
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5908
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
5909
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
5910
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5911
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
5912
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
5913
 
          }// end loop over 't'
5914
 
        }// end loop over 's'
5915
 
      }// end loop over 'r'
5916
 
      for (unsigned int r = 0; r < 3; r++)
5917
 
      {
5918
 
        for (unsigned int s = 0; s < 3 - r; s++)
5919
 
        {
5920
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
5921
 
          {
5922
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
5923
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
5924
 
          }// end loop over 't'
5925
 
        }// end loop over 's'
5926
 
      }// end loop over 'r'
 
4059
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4060
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4061
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4062
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4063
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4064
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4065
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4066
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4067
      basisvalues[0] *= std::sqrt(0.75);
 
4068
      basisvalues[3] *= std::sqrt(1.25);
 
4069
      basisvalues[9] *= std::sqrt(1.75);
 
4070
      basisvalues[2] *= std::sqrt(2.5);
 
4071
      basisvalues[8] *= std::sqrt(3.5);
 
4072
      basisvalues[7] *= std::sqrt(5.25);
 
4073
      basisvalues[1] *= std::sqrt(7.5);
 
4074
      basisvalues[6] *= std::sqrt(10.5);
 
4075
      basisvalues[5] *= std::sqrt(15.75);
 
4076
      basisvalues[4] *= std::sqrt(26.25);
5927
4077
      
5928
4078
      // Table(s) of coefficients.
5929
4079
      static const double coefficients0[10] = \
5943
4093
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
5944
4094
      
5945
4095
      // Declare helper variables.
5946
 
      unsigned int rr = 0;
5947
 
      unsigned int ss = 0;
5948
 
      unsigned int tt = 0;
5949
 
      double tmp5 = 0.0;
5950
 
      double tmp6 = 0.0;
5951
 
      double tmp7 = 0.0;
5952
4096
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
5953
4097
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
5954
4098
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
5958
4102
      // Compute basisvalues.
5959
4103
      basisvalues[0] = 1.0;
5960
4104
      basisvalues[1] = tmp0;
5961
 
      for (unsigned int r = 1; r < 2; r++)
5962
 
      {
5963
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
5964
 
        ss = r*(r + 1)*(r + 2)/6;
5965
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
5966
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
5967
 
      }// end loop over 'r'
5968
 
      for (unsigned int r = 0; r < 2; r++)
5969
 
      {
5970
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
5971
 
        ss = r*(r + 1)*(r + 2)/6;
5972
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
5973
 
      }// end loop over 'r'
5974
 
      for (unsigned int r = 0; r < 1; r++)
5975
 
      {
5976
 
        for (unsigned int s = 1; s < 2 - r; s++)
5977
 
        {
5978
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
5979
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5980
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
5981
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
5982
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5983
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
5984
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
5985
 
        }// end loop over 's'
5986
 
      }// end loop over 'r'
5987
 
      for (unsigned int r = 0; r < 2; r++)
5988
 
      {
5989
 
        for (unsigned int s = 0; s < 2 - r; s++)
5990
 
        {
5991
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
5992
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
5993
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
5994
 
        }// end loop over 's'
5995
 
      }// end loop over 'r'
5996
 
      for (unsigned int r = 0; r < 1; r++)
5997
 
      {
5998
 
        for (unsigned int s = 0; s < 1 - r; s++)
5999
 
        {
6000
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6001
 
          {
6002
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6003
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6004
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6005
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6006
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6007
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6008
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6009
 
          }// end loop over 't'
6010
 
        }// end loop over 's'
6011
 
      }// end loop over 'r'
6012
 
      for (unsigned int r = 0; r < 3; r++)
6013
 
      {
6014
 
        for (unsigned int s = 0; s < 3 - r; s++)
6015
 
        {
6016
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6017
 
          {
6018
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6019
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6020
 
          }// end loop over 't'
6021
 
        }// end loop over 's'
6022
 
      }// end loop over 'r'
 
4105
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4106
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4107
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4108
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4109
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4110
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4111
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4112
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4113
      basisvalues[0] *= std::sqrt(0.75);
 
4114
      basisvalues[3] *= std::sqrt(1.25);
 
4115
      basisvalues[9] *= std::sqrt(1.75);
 
4116
      basisvalues[2] *= std::sqrt(2.5);
 
4117
      basisvalues[8] *= std::sqrt(3.5);
 
4118
      basisvalues[7] *= std::sqrt(5.25);
 
4119
      basisvalues[1] *= std::sqrt(7.5);
 
4120
      basisvalues[6] *= std::sqrt(10.5);
 
4121
      basisvalues[5] *= std::sqrt(15.75);
 
4122
      basisvalues[4] *= std::sqrt(26.25);
6023
4123
      
6024
4124
      // Table(s) of coefficients.
6025
4125
      static const double coefficients0[10] = \
6039
4139
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6040
4140
      
6041
4141
      // Declare helper variables.
6042
 
      unsigned int rr = 0;
6043
 
      unsigned int ss = 0;
6044
 
      unsigned int tt = 0;
6045
 
      double tmp5 = 0.0;
6046
 
      double tmp6 = 0.0;
6047
 
      double tmp7 = 0.0;
6048
4142
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
6049
4143
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
6050
4144
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
6054
4148
      // Compute basisvalues.
6055
4149
      basisvalues[0] = 1.0;
6056
4150
      basisvalues[1] = tmp0;
6057
 
      for (unsigned int r = 1; r < 2; r++)
6058
 
      {
6059
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
6060
 
        ss = r*(r + 1)*(r + 2)/6;
6061
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
6062
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
6063
 
      }// end loop over 'r'
6064
 
      for (unsigned int r = 0; r < 2; r++)
6065
 
      {
6066
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
6067
 
        ss = r*(r + 1)*(r + 2)/6;
6068
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
6069
 
      }// end loop over 'r'
6070
 
      for (unsigned int r = 0; r < 1; r++)
6071
 
      {
6072
 
        for (unsigned int s = 1; s < 2 - r; s++)
6073
 
        {
6074
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
6075
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6076
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
6077
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
6078
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6079
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6080
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
6081
 
        }// end loop over 's'
6082
 
      }// end loop over 'r'
6083
 
      for (unsigned int r = 0; r < 2; r++)
6084
 
      {
6085
 
        for (unsigned int s = 0; s < 2 - r; s++)
6086
 
        {
6087
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
6088
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6089
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
6090
 
        }// end loop over 's'
6091
 
      }// end loop over 'r'
6092
 
      for (unsigned int r = 0; r < 1; r++)
6093
 
      {
6094
 
        for (unsigned int s = 0; s < 1 - r; s++)
6095
 
        {
6096
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6097
 
          {
6098
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6099
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6100
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6101
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6102
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6103
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6104
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6105
 
          }// end loop over 't'
6106
 
        }// end loop over 's'
6107
 
      }// end loop over 'r'
6108
 
      for (unsigned int r = 0; r < 3; r++)
6109
 
      {
6110
 
        for (unsigned int s = 0; s < 3 - r; s++)
6111
 
        {
6112
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6113
 
          {
6114
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6115
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6116
 
          }// end loop over 't'
6117
 
        }// end loop over 's'
6118
 
      }// end loop over 'r'
 
4151
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4152
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4153
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4154
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4155
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4156
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4157
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4158
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4159
      basisvalues[0] *= std::sqrt(0.75);
 
4160
      basisvalues[3] *= std::sqrt(1.25);
 
4161
      basisvalues[9] *= std::sqrt(1.75);
 
4162
      basisvalues[2] *= std::sqrt(2.5);
 
4163
      basisvalues[8] *= std::sqrt(3.5);
 
4164
      basisvalues[7] *= std::sqrt(5.25);
 
4165
      basisvalues[1] *= std::sqrt(7.5);
 
4166
      basisvalues[6] *= std::sqrt(10.5);
 
4167
      basisvalues[5] *= std::sqrt(15.75);
 
4168
      basisvalues[4] *= std::sqrt(26.25);
6119
4169
      
6120
4170
      // Table(s) of coefficients.
6121
4171
      static const double coefficients0[10] = \
6135
4185
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6136
4186
      
6137
4187
      // Declare helper variables.
6138
 
      unsigned int rr = 0;
6139
 
      unsigned int ss = 0;
6140
 
      unsigned int tt = 0;
6141
 
      double tmp5 = 0.0;
6142
 
      double tmp6 = 0.0;
6143
 
      double tmp7 = 0.0;
6144
4188
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
6145
4189
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
6146
4190
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
6150
4194
      // Compute basisvalues.
6151
4195
      basisvalues[0] = 1.0;
6152
4196
      basisvalues[1] = tmp0;
6153
 
      for (unsigned int r = 1; r < 2; r++)
6154
 
      {
6155
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
6156
 
        ss = r*(r + 1)*(r + 2)/6;
6157
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
6158
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
6159
 
      }// end loop over 'r'
6160
 
      for (unsigned int r = 0; r < 2; r++)
6161
 
      {
6162
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
6163
 
        ss = r*(r + 1)*(r + 2)/6;
6164
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
6165
 
      }// end loop over 'r'
6166
 
      for (unsigned int r = 0; r < 1; r++)
6167
 
      {
6168
 
        for (unsigned int s = 1; s < 2 - r; s++)
6169
 
        {
6170
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
6171
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6172
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
6173
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
6174
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6175
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6176
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
6177
 
        }// end loop over 's'
6178
 
      }// end loop over 'r'
6179
 
      for (unsigned int r = 0; r < 2; r++)
6180
 
      {
6181
 
        for (unsigned int s = 0; s < 2 - r; s++)
6182
 
        {
6183
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
6184
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6185
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
6186
 
        }// end loop over 's'
6187
 
      }// end loop over 'r'
6188
 
      for (unsigned int r = 0; r < 1; r++)
6189
 
      {
6190
 
        for (unsigned int s = 0; s < 1 - r; s++)
6191
 
        {
6192
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6193
 
          {
6194
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6195
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6196
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6197
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6198
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6199
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6200
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6201
 
          }// end loop over 't'
6202
 
        }// end loop over 's'
6203
 
      }// end loop over 'r'
6204
 
      for (unsigned int r = 0; r < 3; r++)
6205
 
      {
6206
 
        for (unsigned int s = 0; s < 3 - r; s++)
6207
 
        {
6208
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6209
 
          {
6210
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6211
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6212
 
          }// end loop over 't'
6213
 
        }// end loop over 's'
6214
 
      }// end loop over 'r'
 
4197
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4198
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4199
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4200
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4201
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4202
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4203
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4204
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4205
      basisvalues[0] *= std::sqrt(0.75);
 
4206
      basisvalues[3] *= std::sqrt(1.25);
 
4207
      basisvalues[9] *= std::sqrt(1.75);
 
4208
      basisvalues[2] *= std::sqrt(2.5);
 
4209
      basisvalues[8] *= std::sqrt(3.5);
 
4210
      basisvalues[7] *= std::sqrt(5.25);
 
4211
      basisvalues[1] *= std::sqrt(7.5);
 
4212
      basisvalues[6] *= std::sqrt(10.5);
 
4213
      basisvalues[5] *= std::sqrt(15.75);
 
4214
      basisvalues[4] *= std::sqrt(26.25);
6215
4215
      
6216
4216
      // Table(s) of coefficients.
6217
4217
      static const double coefficients0[10] = \
6231
4231
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6232
4232
      
6233
4233
      // Declare helper variables.
6234
 
      unsigned int rr = 0;
6235
 
      unsigned int ss = 0;
6236
 
      unsigned int tt = 0;
6237
 
      double tmp5 = 0.0;
6238
 
      double tmp6 = 0.0;
6239
 
      double tmp7 = 0.0;
6240
4234
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
6241
4235
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
6242
4236
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
6246
4240
      // Compute basisvalues.
6247
4241
      basisvalues[0] = 1.0;
6248
4242
      basisvalues[1] = tmp0;
6249
 
      for (unsigned int r = 1; r < 2; r++)
6250
 
      {
6251
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
6252
 
        ss = r*(r + 1)*(r + 2)/6;
6253
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
6254
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
6255
 
      }// end loop over 'r'
6256
 
      for (unsigned int r = 0; r < 2; r++)
6257
 
      {
6258
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
6259
 
        ss = r*(r + 1)*(r + 2)/6;
6260
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
6261
 
      }// end loop over 'r'
6262
 
      for (unsigned int r = 0; r < 1; r++)
6263
 
      {
6264
 
        for (unsigned int s = 1; s < 2 - r; s++)
6265
 
        {
6266
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
6267
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6268
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
6269
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
6270
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6271
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6272
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
6273
 
        }// end loop over 's'
6274
 
      }// end loop over 'r'
6275
 
      for (unsigned int r = 0; r < 2; r++)
6276
 
      {
6277
 
        for (unsigned int s = 0; s < 2 - r; s++)
6278
 
        {
6279
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
6280
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6281
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
6282
 
        }// end loop over 's'
6283
 
      }// end loop over 'r'
6284
 
      for (unsigned int r = 0; r < 1; r++)
6285
 
      {
6286
 
        for (unsigned int s = 0; s < 1 - r; s++)
6287
 
        {
6288
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6289
 
          {
6290
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6291
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6292
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6293
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6294
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6295
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6296
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6297
 
          }// end loop over 't'
6298
 
        }// end loop over 's'
6299
 
      }// end loop over 'r'
6300
 
      for (unsigned int r = 0; r < 3; r++)
6301
 
      {
6302
 
        for (unsigned int s = 0; s < 3 - r; s++)
6303
 
        {
6304
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6305
 
          {
6306
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6307
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6308
 
          }// end loop over 't'
6309
 
        }// end loop over 's'
6310
 
      }// end loop over 'r'
 
4243
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4244
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4245
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4246
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4247
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4248
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4249
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4250
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4251
      basisvalues[0] *= std::sqrt(0.75);
 
4252
      basisvalues[3] *= std::sqrt(1.25);
 
4253
      basisvalues[9] *= std::sqrt(1.75);
 
4254
      basisvalues[2] *= std::sqrt(2.5);
 
4255
      basisvalues[8] *= std::sqrt(3.5);
 
4256
      basisvalues[7] *= std::sqrt(5.25);
 
4257
      basisvalues[1] *= std::sqrt(7.5);
 
4258
      basisvalues[6] *= std::sqrt(10.5);
 
4259
      basisvalues[5] *= std::sqrt(15.75);
 
4260
      basisvalues[4] *= std::sqrt(26.25);
6311
4261
      
6312
4262
      // Table(s) of coefficients.
6313
4263
      static const double coefficients0[10] = \
6327
4277
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6328
4278
      
6329
4279
      // Declare helper variables.
6330
 
      unsigned int rr = 0;
6331
 
      unsigned int ss = 0;
6332
 
      unsigned int tt = 0;
6333
 
      double tmp5 = 0.0;
6334
 
      double tmp6 = 0.0;
6335
 
      double tmp7 = 0.0;
6336
4280
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
6337
4281
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
6338
4282
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
6342
4286
      // Compute basisvalues.
6343
4287
      basisvalues[0] = 1.0;
6344
4288
      basisvalues[1] = tmp0;
6345
 
      for (unsigned int r = 1; r < 2; r++)
6346
 
      {
6347
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
6348
 
        ss = r*(r + 1)*(r + 2)/6;
6349
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
6350
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
6351
 
      }// end loop over 'r'
6352
 
      for (unsigned int r = 0; r < 2; r++)
6353
 
      {
6354
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
6355
 
        ss = r*(r + 1)*(r + 2)/6;
6356
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
6357
 
      }// end loop over 'r'
6358
 
      for (unsigned int r = 0; r < 1; r++)
6359
 
      {
6360
 
        for (unsigned int s = 1; s < 2 - r; s++)
6361
 
        {
6362
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
6363
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6364
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
6365
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
6366
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6367
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6368
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
6369
 
        }// end loop over 's'
6370
 
      }// end loop over 'r'
6371
 
      for (unsigned int r = 0; r < 2; r++)
6372
 
      {
6373
 
        for (unsigned int s = 0; s < 2 - r; s++)
6374
 
        {
6375
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
6376
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6377
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
6378
 
        }// end loop over 's'
6379
 
      }// end loop over 'r'
6380
 
      for (unsigned int r = 0; r < 1; r++)
6381
 
      {
6382
 
        for (unsigned int s = 0; s < 1 - r; s++)
6383
 
        {
6384
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6385
 
          {
6386
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6387
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6388
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6389
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6390
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6391
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6392
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6393
 
          }// end loop over 't'
6394
 
        }// end loop over 's'
6395
 
      }// end loop over 'r'
6396
 
      for (unsigned int r = 0; r < 3; r++)
6397
 
      {
6398
 
        for (unsigned int s = 0; s < 3 - r; s++)
6399
 
        {
6400
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6401
 
          {
6402
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6403
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6404
 
          }// end loop over 't'
6405
 
        }// end loop over 's'
6406
 
      }// end loop over 'r'
 
4289
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4290
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4291
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4292
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4293
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4294
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4295
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4296
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4297
      basisvalues[0] *= std::sqrt(0.75);
 
4298
      basisvalues[3] *= std::sqrt(1.25);
 
4299
      basisvalues[9] *= std::sqrt(1.75);
 
4300
      basisvalues[2] *= std::sqrt(2.5);
 
4301
      basisvalues[8] *= std::sqrt(3.5);
 
4302
      basisvalues[7] *= std::sqrt(5.25);
 
4303
      basisvalues[1] *= std::sqrt(7.5);
 
4304
      basisvalues[6] *= std::sqrt(10.5);
 
4305
      basisvalues[5] *= std::sqrt(15.75);
 
4306
      basisvalues[4] *= std::sqrt(26.25);
6407
4307
      
6408
4308
      // Table(s) of coefficients.
6409
4309
      static const double coefficients0[10] = \
6423
4323
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6424
4324
      
6425
4325
      // Declare helper variables.
6426
 
      unsigned int rr = 0;
6427
 
      unsigned int ss = 0;
6428
 
      unsigned int tt = 0;
6429
 
      double tmp5 = 0.0;
6430
 
      double tmp6 = 0.0;
6431
 
      double tmp7 = 0.0;
6432
4326
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
6433
4327
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
6434
4328
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
6438
4332
      // Compute basisvalues.
6439
4333
      basisvalues[0] = 1.0;
6440
4334
      basisvalues[1] = tmp0;
6441
 
      for (unsigned int r = 1; r < 2; r++)
6442
 
      {
6443
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
6444
 
        ss = r*(r + 1)*(r + 2)/6;
6445
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
6446
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
6447
 
      }// end loop over 'r'
6448
 
      for (unsigned int r = 0; r < 2; r++)
6449
 
      {
6450
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
6451
 
        ss = r*(r + 1)*(r + 2)/6;
6452
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
6453
 
      }// end loop over 'r'
6454
 
      for (unsigned int r = 0; r < 1; r++)
6455
 
      {
6456
 
        for (unsigned int s = 1; s < 2 - r; s++)
6457
 
        {
6458
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
6459
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6460
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
6461
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
6462
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6463
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6464
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
6465
 
        }// end loop over 's'
6466
 
      }// end loop over 'r'
6467
 
      for (unsigned int r = 0; r < 2; r++)
6468
 
      {
6469
 
        for (unsigned int s = 0; s < 2 - r; s++)
6470
 
        {
6471
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
6472
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6473
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
6474
 
        }// end loop over 's'
6475
 
      }// end loop over 'r'
6476
 
      for (unsigned int r = 0; r < 1; r++)
6477
 
      {
6478
 
        for (unsigned int s = 0; s < 1 - r; s++)
6479
 
        {
6480
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6481
 
          {
6482
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6483
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6484
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6485
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6486
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6487
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6488
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6489
 
          }// end loop over 't'
6490
 
        }// end loop over 's'
6491
 
      }// end loop over 'r'
6492
 
      for (unsigned int r = 0; r < 3; r++)
6493
 
      {
6494
 
        for (unsigned int s = 0; s < 3 - r; s++)
6495
 
        {
6496
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6497
 
          {
6498
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6499
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6500
 
          }// end loop over 't'
6501
 
        }// end loop over 's'
6502
 
      }// end loop over 'r'
 
4335
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4336
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4337
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4338
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4339
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4340
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4341
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4342
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4343
      basisvalues[0] *= std::sqrt(0.75);
 
4344
      basisvalues[3] *= std::sqrt(1.25);
 
4345
      basisvalues[9] *= std::sqrt(1.75);
 
4346
      basisvalues[2] *= std::sqrt(2.5);
 
4347
      basisvalues[8] *= std::sqrt(3.5);
 
4348
      basisvalues[7] *= std::sqrt(5.25);
 
4349
      basisvalues[1] *= std::sqrt(7.5);
 
4350
      basisvalues[6] *= std::sqrt(10.5);
 
4351
      basisvalues[5] *= std::sqrt(15.75);
 
4352
      basisvalues[4] *= std::sqrt(26.25);
6503
4353
      
6504
4354
      // Table(s) of coefficients.
6505
4355
      static const double coefficients0[10] = \
6519
4369
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6520
4370
      
6521
4371
      // Declare helper variables.
6522
 
      unsigned int rr = 0;
6523
 
      unsigned int ss = 0;
6524
 
      unsigned int tt = 0;
6525
 
      double tmp5 = 0.0;
6526
 
      double tmp6 = 0.0;
6527
 
      double tmp7 = 0.0;
6528
4372
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
6529
4373
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
6530
4374
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
6534
4378
      // Compute basisvalues.
6535
4379
      basisvalues[0] = 1.0;
6536
4380
      basisvalues[1] = tmp0;
6537
 
      for (unsigned int r = 1; r < 2; r++)
6538
 
      {
6539
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
6540
 
        ss = r*(r + 1)*(r + 2)/6;
6541
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
6542
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
6543
 
      }// end loop over 'r'
6544
 
      for (unsigned int r = 0; r < 2; r++)
6545
 
      {
6546
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
6547
 
        ss = r*(r + 1)*(r + 2)/6;
6548
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
6549
 
      }// end loop over 'r'
6550
 
      for (unsigned int r = 0; r < 1; r++)
6551
 
      {
6552
 
        for (unsigned int s = 1; s < 2 - r; s++)
6553
 
        {
6554
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
6555
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6556
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
6557
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
6558
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6559
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6560
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
6561
 
        }// end loop over 's'
6562
 
      }// end loop over 'r'
6563
 
      for (unsigned int r = 0; r < 2; r++)
6564
 
      {
6565
 
        for (unsigned int s = 0; s < 2 - r; s++)
6566
 
        {
6567
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
6568
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6569
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
6570
 
        }// end loop over 's'
6571
 
      }// end loop over 'r'
6572
 
      for (unsigned int r = 0; r < 1; r++)
6573
 
      {
6574
 
        for (unsigned int s = 0; s < 1 - r; s++)
6575
 
        {
6576
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6577
 
          {
6578
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6579
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6580
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6581
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6582
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6583
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6584
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6585
 
          }// end loop over 't'
6586
 
        }// end loop over 's'
6587
 
      }// end loop over 'r'
6588
 
      for (unsigned int r = 0; r < 3; r++)
6589
 
      {
6590
 
        for (unsigned int s = 0; s < 3 - r; s++)
6591
 
        {
6592
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6593
 
          {
6594
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6595
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6596
 
          }// end loop over 't'
6597
 
        }// end loop over 's'
6598
 
      }// end loop over 'r'
 
4381
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4382
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4383
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4384
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4385
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4386
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4387
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4388
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4389
      basisvalues[0] *= std::sqrt(0.75);
 
4390
      basisvalues[3] *= std::sqrt(1.25);
 
4391
      basisvalues[9] *= std::sqrt(1.75);
 
4392
      basisvalues[2] *= std::sqrt(2.5);
 
4393
      basisvalues[8] *= std::sqrt(3.5);
 
4394
      basisvalues[7] *= std::sqrt(5.25);
 
4395
      basisvalues[1] *= std::sqrt(7.5);
 
4396
      basisvalues[6] *= std::sqrt(10.5);
 
4397
      basisvalues[5] *= std::sqrt(15.75);
 
4398
      basisvalues[4] *= std::sqrt(26.25);
6599
4399
      
6600
4400
      // Table(s) of coefficients.
6601
4401
      static const double coefficients0[10] = \
6615
4415
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6616
4416
      
6617
4417
      // Declare helper variables.
6618
 
      unsigned int rr = 0;
6619
 
      unsigned int ss = 0;
6620
 
      unsigned int tt = 0;
6621
 
      double tmp5 = 0.0;
6622
 
      double tmp6 = 0.0;
6623
 
      double tmp7 = 0.0;
6624
4418
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
6625
4419
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
6626
4420
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
6630
4424
      // Compute basisvalues.
6631
4425
      basisvalues[0] = 1.0;
6632
4426
      basisvalues[1] = tmp0;
6633
 
      for (unsigned int r = 1; r < 2; r++)
6634
 
      {
6635
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
6636
 
        ss = r*(r + 1)*(r + 2)/6;
6637
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
6638
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
6639
 
      }// end loop over 'r'
6640
 
      for (unsigned int r = 0; r < 2; r++)
6641
 
      {
6642
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
6643
 
        ss = r*(r + 1)*(r + 2)/6;
6644
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
6645
 
      }// end loop over 'r'
6646
 
      for (unsigned int r = 0; r < 1; r++)
6647
 
      {
6648
 
        for (unsigned int s = 1; s < 2 - r; s++)
6649
 
        {
6650
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
6651
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6652
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
6653
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
6654
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6655
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6656
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
6657
 
        }// end loop over 's'
6658
 
      }// end loop over 'r'
6659
 
      for (unsigned int r = 0; r < 2; r++)
6660
 
      {
6661
 
        for (unsigned int s = 0; s < 2 - r; s++)
6662
 
        {
6663
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
6664
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6665
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
6666
 
        }// end loop over 's'
6667
 
      }// end loop over 'r'
6668
 
      for (unsigned int r = 0; r < 1; r++)
6669
 
      {
6670
 
        for (unsigned int s = 0; s < 1 - r; s++)
6671
 
        {
6672
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6673
 
          {
6674
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6675
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6676
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6677
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6678
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6679
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6680
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6681
 
          }// end loop over 't'
6682
 
        }// end loop over 's'
6683
 
      }// end loop over 'r'
6684
 
      for (unsigned int r = 0; r < 3; r++)
6685
 
      {
6686
 
        for (unsigned int s = 0; s < 3 - r; s++)
6687
 
        {
6688
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6689
 
          {
6690
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6691
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6692
 
          }// end loop over 't'
6693
 
        }// end loop over 's'
6694
 
      }// end loop over 'r'
 
4427
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4428
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4429
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4430
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4431
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4432
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4433
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4434
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4435
      basisvalues[0] *= std::sqrt(0.75);
 
4436
      basisvalues[3] *= std::sqrt(1.25);
 
4437
      basisvalues[9] *= std::sqrt(1.75);
 
4438
      basisvalues[2] *= std::sqrt(2.5);
 
4439
      basisvalues[8] *= std::sqrt(3.5);
 
4440
      basisvalues[7] *= std::sqrt(5.25);
 
4441
      basisvalues[1] *= std::sqrt(7.5);
 
4442
      basisvalues[6] *= std::sqrt(10.5);
 
4443
      basisvalues[5] *= std::sqrt(15.75);
 
4444
      basisvalues[4] *= std::sqrt(26.25);
6695
4445
      
6696
4446
      // Table(s) of coefficients.
6697
4447
      static const double coefficients0[10] = \
6711
4461
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6712
4462
      
6713
4463
      // Declare helper variables.
6714
 
      unsigned int rr = 0;
6715
 
      unsigned int ss = 0;
6716
 
      unsigned int tt = 0;
6717
 
      double tmp5 = 0.0;
6718
 
      double tmp6 = 0.0;
6719
 
      double tmp7 = 0.0;
6720
4464
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
6721
4465
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
6722
4466
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
6726
4470
      // Compute basisvalues.
6727
4471
      basisvalues[0] = 1.0;
6728
4472
      basisvalues[1] = tmp0;
6729
 
      for (unsigned int r = 1; r < 2; r++)
6730
 
      {
6731
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
6732
 
        ss = r*(r + 1)*(r + 2)/6;
6733
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
6734
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
6735
 
      }// end loop over 'r'
6736
 
      for (unsigned int r = 0; r < 2; r++)
6737
 
      {
6738
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
6739
 
        ss = r*(r + 1)*(r + 2)/6;
6740
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
6741
 
      }// end loop over 'r'
6742
 
      for (unsigned int r = 0; r < 1; r++)
6743
 
      {
6744
 
        for (unsigned int s = 1; s < 2 - r; s++)
6745
 
        {
6746
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
6747
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6748
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
6749
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
6750
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6751
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6752
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
6753
 
        }// end loop over 's'
6754
 
      }// end loop over 'r'
6755
 
      for (unsigned int r = 0; r < 2; r++)
6756
 
      {
6757
 
        for (unsigned int s = 0; s < 2 - r; s++)
6758
 
        {
6759
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
6760
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6761
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
6762
 
        }// end loop over 's'
6763
 
      }// end loop over 'r'
6764
 
      for (unsigned int r = 0; r < 1; r++)
6765
 
      {
6766
 
        for (unsigned int s = 0; s < 1 - r; s++)
6767
 
        {
6768
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6769
 
          {
6770
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6771
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6772
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6773
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6774
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6775
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6776
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6777
 
          }// end loop over 't'
6778
 
        }// end loop over 's'
6779
 
      }// end loop over 'r'
6780
 
      for (unsigned int r = 0; r < 3; r++)
6781
 
      {
6782
 
        for (unsigned int s = 0; s < 3 - r; s++)
6783
 
        {
6784
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6785
 
          {
6786
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6787
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6788
 
          }// end loop over 't'
6789
 
        }// end loop over 's'
6790
 
      }// end loop over 'r'
 
4473
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4474
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4475
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4476
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4477
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4478
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4479
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4480
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4481
      basisvalues[0] *= std::sqrt(0.75);
 
4482
      basisvalues[3] *= std::sqrt(1.25);
 
4483
      basisvalues[9] *= std::sqrt(1.75);
 
4484
      basisvalues[2] *= std::sqrt(2.5);
 
4485
      basisvalues[8] *= std::sqrt(3.5);
 
4486
      basisvalues[7] *= std::sqrt(5.25);
 
4487
      basisvalues[1] *= std::sqrt(7.5);
 
4488
      basisvalues[6] *= std::sqrt(10.5);
 
4489
      basisvalues[5] *= std::sqrt(15.75);
 
4490
      basisvalues[4] *= std::sqrt(26.25);
6791
4491
      
6792
4492
      // Table(s) of coefficients.
6793
4493
      static const double coefficients0[10] = \
6807
4507
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6808
4508
      
6809
4509
      // Declare helper variables.
6810
 
      unsigned int rr = 0;
6811
 
      unsigned int ss = 0;
6812
 
      unsigned int tt = 0;
6813
 
      double tmp5 = 0.0;
6814
 
      double tmp6 = 0.0;
6815
 
      double tmp7 = 0.0;
6816
4510
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
6817
4511
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
6818
4512
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
6822
4516
      // Compute basisvalues.
6823
4517
      basisvalues[0] = 1.0;
6824
4518
      basisvalues[1] = tmp0;
6825
 
      for (unsigned int r = 1; r < 2; r++)
6826
 
      {
6827
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
6828
 
        ss = r*(r + 1)*(r + 2)/6;
6829
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
6830
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
6831
 
      }// end loop over 'r'
6832
 
      for (unsigned int r = 0; r < 2; r++)
6833
 
      {
6834
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
6835
 
        ss = r*(r + 1)*(r + 2)/6;
6836
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
6837
 
      }// end loop over 'r'
6838
 
      for (unsigned int r = 0; r < 1; r++)
6839
 
      {
6840
 
        for (unsigned int s = 1; s < 2 - r; s++)
6841
 
        {
6842
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
6843
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6844
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
6845
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
6846
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6847
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6848
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
6849
 
        }// end loop over 's'
6850
 
      }// end loop over 'r'
6851
 
      for (unsigned int r = 0; r < 2; r++)
6852
 
      {
6853
 
        for (unsigned int s = 0; s < 2 - r; s++)
6854
 
        {
6855
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
6856
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6857
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
6858
 
        }// end loop over 's'
6859
 
      }// end loop over 'r'
6860
 
      for (unsigned int r = 0; r < 1; r++)
6861
 
      {
6862
 
        for (unsigned int s = 0; s < 1 - r; s++)
6863
 
        {
6864
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6865
 
          {
6866
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6867
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6868
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6869
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6870
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6871
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6872
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6873
 
          }// end loop over 't'
6874
 
        }// end loop over 's'
6875
 
      }// end loop over 'r'
6876
 
      for (unsigned int r = 0; r < 3; r++)
6877
 
      {
6878
 
        for (unsigned int s = 0; s < 3 - r; s++)
6879
 
        {
6880
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6881
 
          {
6882
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6883
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6884
 
          }// end loop over 't'
6885
 
        }// end loop over 's'
6886
 
      }// end loop over 'r'
 
4519
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4520
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4521
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4522
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4523
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4524
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4525
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4526
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4527
      basisvalues[0] *= std::sqrt(0.75);
 
4528
      basisvalues[3] *= std::sqrt(1.25);
 
4529
      basisvalues[9] *= std::sqrt(1.75);
 
4530
      basisvalues[2] *= std::sqrt(2.5);
 
4531
      basisvalues[8] *= std::sqrt(3.5);
 
4532
      basisvalues[7] *= std::sqrt(5.25);
 
4533
      basisvalues[1] *= std::sqrt(7.5);
 
4534
      basisvalues[6] *= std::sqrt(10.5);
 
4535
      basisvalues[5] *= std::sqrt(15.75);
 
4536
      basisvalues[4] *= std::sqrt(26.25);
6887
4537
      
6888
4538
      // Table(s) of coefficients.
6889
4539
      static const double coefficients0[10] = \
6903
4553
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6904
4554
      
6905
4555
      // Declare helper variables.
6906
 
      unsigned int rr = 0;
6907
 
      unsigned int ss = 0;
6908
 
      unsigned int tt = 0;
6909
 
      double tmp5 = 0.0;
6910
 
      double tmp6 = 0.0;
6911
 
      double tmp7 = 0.0;
6912
4556
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
6913
4557
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
6914
4558
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
6918
4562
      // Compute basisvalues.
6919
4563
      basisvalues[0] = 1.0;
6920
4564
      basisvalues[1] = tmp0;
6921
 
      for (unsigned int r = 1; r < 2; r++)
6922
 
      {
6923
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
6924
 
        ss = r*(r + 1)*(r + 2)/6;
6925
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
6926
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
6927
 
      }// end loop over 'r'
6928
 
      for (unsigned int r = 0; r < 2; r++)
6929
 
      {
6930
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
6931
 
        ss = r*(r + 1)*(r + 2)/6;
6932
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
6933
 
      }// end loop over 'r'
6934
 
      for (unsigned int r = 0; r < 1; r++)
6935
 
      {
6936
 
        for (unsigned int s = 1; s < 2 - r; s++)
6937
 
        {
6938
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
6939
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6940
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
6941
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
6942
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6943
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
6944
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
6945
 
        }// end loop over 's'
6946
 
      }// end loop over 'r'
6947
 
      for (unsigned int r = 0; r < 2; r++)
6948
 
      {
6949
 
        for (unsigned int s = 0; s < 2 - r; s++)
6950
 
        {
6951
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
6952
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
6953
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
6954
 
        }// end loop over 's'
6955
 
      }// end loop over 'r'
6956
 
      for (unsigned int r = 0; r < 1; r++)
6957
 
      {
6958
 
        for (unsigned int s = 0; s < 1 - r; s++)
6959
 
        {
6960
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
6961
 
          {
6962
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
6963
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6964
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
6965
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
6966
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6967
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
6968
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
6969
 
          }// end loop over 't'
6970
 
        }// end loop over 's'
6971
 
      }// end loop over 'r'
6972
 
      for (unsigned int r = 0; r < 3; r++)
6973
 
      {
6974
 
        for (unsigned int s = 0; s < 3 - r; s++)
6975
 
        {
6976
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
6977
 
          {
6978
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
6979
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
6980
 
          }// end loop over 't'
6981
 
        }// end loop over 's'
6982
 
      }// end loop over 'r'
 
4565
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4566
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4567
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4568
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4569
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4570
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4571
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4572
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4573
      basisvalues[0] *= std::sqrt(0.75);
 
4574
      basisvalues[3] *= std::sqrt(1.25);
 
4575
      basisvalues[9] *= std::sqrt(1.75);
 
4576
      basisvalues[2] *= std::sqrt(2.5);
 
4577
      basisvalues[8] *= std::sqrt(3.5);
 
4578
      basisvalues[7] *= std::sqrt(5.25);
 
4579
      basisvalues[1] *= std::sqrt(7.5);
 
4580
      basisvalues[6] *= std::sqrt(10.5);
 
4581
      basisvalues[5] *= std::sqrt(15.75);
 
4582
      basisvalues[4] *= std::sqrt(26.25);
6983
4583
      
6984
4584
      // Table(s) of coefficients.
6985
4585
      static const double coefficients0[10] = \
6999
4599
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
7000
4600
      
7001
4601
      // Declare helper variables.
7002
 
      unsigned int rr = 0;
7003
 
      unsigned int ss = 0;
7004
 
      unsigned int tt = 0;
7005
 
      double tmp5 = 0.0;
7006
 
      double tmp6 = 0.0;
7007
 
      double tmp7 = 0.0;
7008
4602
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
7009
4603
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
7010
4604
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
7014
4608
      // Compute basisvalues.
7015
4609
      basisvalues[0] = 1.0;
7016
4610
      basisvalues[1] = tmp0;
7017
 
      for (unsigned int r = 1; r < 2; r++)
7018
 
      {
7019
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
7020
 
        ss = r*(r + 1)*(r + 2)/6;
7021
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
7022
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
7023
 
      }// end loop over 'r'
7024
 
      for (unsigned int r = 0; r < 2; r++)
7025
 
      {
7026
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
7027
 
        ss = r*(r + 1)*(r + 2)/6;
7028
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
7029
 
      }// end loop over 'r'
7030
 
      for (unsigned int r = 0; r < 1; r++)
7031
 
      {
7032
 
        for (unsigned int s = 1; s < 2 - r; s++)
7033
 
        {
7034
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
7035
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
7036
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
7037
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
7038
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
7039
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
7040
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
7041
 
        }// end loop over 's'
7042
 
      }// end loop over 'r'
7043
 
      for (unsigned int r = 0; r < 2; r++)
7044
 
      {
7045
 
        for (unsigned int s = 0; s < 2 - r; s++)
7046
 
        {
7047
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
7048
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
7049
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
7050
 
        }// end loop over 's'
7051
 
      }// end loop over 'r'
7052
 
      for (unsigned int r = 0; r < 1; r++)
7053
 
      {
7054
 
        for (unsigned int s = 0; s < 1 - r; s++)
7055
 
        {
7056
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
7057
 
          {
7058
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
7059
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
7060
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
7061
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
7062
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
7063
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
7064
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
7065
 
          }// end loop over 't'
7066
 
        }// end loop over 's'
7067
 
      }// end loop over 'r'
7068
 
      for (unsigned int r = 0; r < 3; r++)
7069
 
      {
7070
 
        for (unsigned int s = 0; s < 3 - r; s++)
7071
 
        {
7072
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
7073
 
          {
7074
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
7075
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
7076
 
          }// end loop over 't'
7077
 
        }// end loop over 's'
7078
 
      }// end loop over 'r'
 
4611
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4612
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4613
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4614
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4615
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4616
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4617
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4618
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4619
      basisvalues[0] *= std::sqrt(0.75);
 
4620
      basisvalues[3] *= std::sqrt(1.25);
 
4621
      basisvalues[9] *= std::sqrt(1.75);
 
4622
      basisvalues[2] *= std::sqrt(2.5);
 
4623
      basisvalues[8] *= std::sqrt(3.5);
 
4624
      basisvalues[7] *= std::sqrt(5.25);
 
4625
      basisvalues[1] *= std::sqrt(7.5);
 
4626
      basisvalues[6] *= std::sqrt(10.5);
 
4627
      basisvalues[5] *= std::sqrt(15.75);
 
4628
      basisvalues[4] *= std::sqrt(26.25);
7079
4629
      
7080
4630
      // Table(s) of coefficients.
7081
4631
      static const double coefficients0[10] = \
7095
4645
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
7096
4646
      
7097
4647
      // Declare helper variables.
7098
 
      unsigned int rr = 0;
7099
 
      unsigned int ss = 0;
7100
 
      unsigned int tt = 0;
7101
 
      double tmp5 = 0.0;
7102
 
      double tmp6 = 0.0;
7103
 
      double tmp7 = 0.0;
7104
4648
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
7105
4649
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
7106
4650
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
7110
4654
      // Compute basisvalues.
7111
4655
      basisvalues[0] = 1.0;
7112
4656
      basisvalues[1] = tmp0;
7113
 
      for (unsigned int r = 1; r < 2; r++)
7114
 
      {
7115
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
7116
 
        ss = r*(r + 1)*(r + 2)/6;
7117
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
7118
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
7119
 
      }// end loop over 'r'
7120
 
      for (unsigned int r = 0; r < 2; r++)
7121
 
      {
7122
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
7123
 
        ss = r*(r + 1)*(r + 2)/6;
7124
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
7125
 
      }// end loop over 'r'
7126
 
      for (unsigned int r = 0; r < 1; r++)
7127
 
      {
7128
 
        for (unsigned int s = 1; s < 2 - r; s++)
7129
 
        {
7130
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
7131
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
7132
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
7133
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
7134
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
7135
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
7136
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
7137
 
        }// end loop over 's'
7138
 
      }// end loop over 'r'
7139
 
      for (unsigned int r = 0; r < 2; r++)
7140
 
      {
7141
 
        for (unsigned int s = 0; s < 2 - r; s++)
7142
 
        {
7143
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
7144
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
7145
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
7146
 
        }// end loop over 's'
7147
 
      }// end loop over 'r'
7148
 
      for (unsigned int r = 0; r < 1; r++)
7149
 
      {
7150
 
        for (unsigned int s = 0; s < 1 - r; s++)
7151
 
        {
7152
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
7153
 
          {
7154
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
7155
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
7156
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
7157
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
7158
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
7159
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
7160
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
7161
 
          }// end loop over 't'
7162
 
        }// end loop over 's'
7163
 
      }// end loop over 'r'
7164
 
      for (unsigned int r = 0; r < 3; r++)
7165
 
      {
7166
 
        for (unsigned int s = 0; s < 3 - r; s++)
7167
 
        {
7168
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
7169
 
          {
7170
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
7171
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
7172
 
          }// end loop over 't'
7173
 
        }// end loop over 's'
7174
 
      }// end loop over 'r'
 
4657
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4658
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4659
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4660
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4661
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4662
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4663
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4664
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4665
      basisvalues[0] *= std::sqrt(0.75);
 
4666
      basisvalues[3] *= std::sqrt(1.25);
 
4667
      basisvalues[9] *= std::sqrt(1.75);
 
4668
      basisvalues[2] *= std::sqrt(2.5);
 
4669
      basisvalues[8] *= std::sqrt(3.5);
 
4670
      basisvalues[7] *= std::sqrt(5.25);
 
4671
      basisvalues[1] *= std::sqrt(7.5);
 
4672
      basisvalues[6] *= std::sqrt(10.5);
 
4673
      basisvalues[5] *= std::sqrt(15.75);
 
4674
      basisvalues[4] *= std::sqrt(26.25);
7175
4675
      
7176
4676
      // Table(s) of coefficients.
7177
4677
      static const double coefficients0[10] = \
7337
4837
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
7338
4838
      
7339
4839
      // Declare helper variables.
7340
 
      unsigned int rr = 0;
7341
 
      unsigned int ss = 0;
7342
 
      unsigned int tt = 0;
7343
 
      double tmp5 = 0.0;
7344
 
      double tmp6 = 0.0;
7345
 
      double tmp7 = 0.0;
7346
4840
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
7347
4841
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
7348
4842
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
7352
4846
      // Compute basisvalues.
7353
4847
      basisvalues[0] = 1.0;
7354
4848
      basisvalues[1] = tmp0;
7355
 
      for (unsigned int r = 1; r < 2; r++)
7356
 
      {
7357
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
7358
 
        ss = r*(r + 1)*(r + 2)/6;
7359
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
7360
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
7361
 
      }// end loop over 'r'
7362
 
      for (unsigned int r = 0; r < 2; r++)
7363
 
      {
7364
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
7365
 
        ss = r*(r + 1)*(r + 2)/6;
7366
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
7367
 
      }// end loop over 'r'
7368
 
      for (unsigned int r = 0; r < 1; r++)
7369
 
      {
7370
 
        for (unsigned int s = 1; s < 2 - r; s++)
7371
 
        {
7372
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
7373
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
7374
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
7375
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
7376
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
7377
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
7378
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
7379
 
        }// end loop over 's'
7380
 
      }// end loop over 'r'
7381
 
      for (unsigned int r = 0; r < 2; r++)
7382
 
      {
7383
 
        for (unsigned int s = 0; s < 2 - r; s++)
7384
 
        {
7385
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
7386
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
7387
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
7388
 
        }// end loop over 's'
7389
 
      }// end loop over 'r'
7390
 
      for (unsigned int r = 0; r < 1; r++)
7391
 
      {
7392
 
        for (unsigned int s = 0; s < 1 - r; s++)
7393
 
        {
7394
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
7395
 
          {
7396
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
7397
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
7398
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
7399
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
7400
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
7401
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
7402
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
7403
 
          }// end loop over 't'
7404
 
        }// end loop over 's'
7405
 
      }// end loop over 'r'
7406
 
      for (unsigned int r = 0; r < 3; r++)
7407
 
      {
7408
 
        for (unsigned int s = 0; s < 3 - r; s++)
7409
 
        {
7410
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
7411
 
          {
7412
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
7413
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
7414
 
          }// end loop over 't'
7415
 
        }// end loop over 's'
7416
 
      }// end loop over 'r'
 
4849
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
4850
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
4851
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
4852
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
4853
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
4854
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
4855
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
4856
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
4857
      basisvalues[0] *= std::sqrt(0.75);
 
4858
      basisvalues[3] *= std::sqrt(1.25);
 
4859
      basisvalues[9] *= std::sqrt(1.75);
 
4860
      basisvalues[2] *= std::sqrt(2.5);
 
4861
      basisvalues[8] *= std::sqrt(3.5);
 
4862
      basisvalues[7] *= std::sqrt(5.25);
 
4863
      basisvalues[1] *= std::sqrt(7.5);
 
4864
      basisvalues[6] *= std::sqrt(10.5);
 
4865
      basisvalues[5] *= std::sqrt(15.75);
 
4866
      basisvalues[4] *= std::sqrt(26.25);
7417
4867
      
7418
4868
      // Table(s) of coefficients.
7419
4869
      static const double coefficients0[10] = \
7605
5055
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
7606
5056
      
7607
5057
      // Declare helper variables.
7608
 
      unsigned int rr = 0;
7609
 
      unsigned int ss = 0;
7610
 
      unsigned int tt = 0;
7611
 
      double tmp5 = 0.0;
7612
 
      double tmp6 = 0.0;
7613
 
      double tmp7 = 0.0;
7614
5058
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
7615
5059
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
7616
5060
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
7620
5064
      // Compute basisvalues.
7621
5065
      basisvalues[0] = 1.0;
7622
5066
      basisvalues[1] = tmp0;
7623
 
      for (unsigned int r = 1; r < 2; r++)
7624
 
      {
7625
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
7626
 
        ss = r*(r + 1)*(r + 2)/6;
7627
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
7628
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
7629
 
      }// end loop over 'r'
7630
 
      for (unsigned int r = 0; r < 2; r++)
7631
 
      {
7632
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
7633
 
        ss = r*(r + 1)*(r + 2)/6;
7634
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
7635
 
      }// end loop over 'r'
7636
 
      for (unsigned int r = 0; r < 1; r++)
7637
 
      {
7638
 
        for (unsigned int s = 1; s < 2 - r; s++)
7639
 
        {
7640
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
7641
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
7642
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
7643
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
7644
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
7645
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
7646
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
7647
 
        }// end loop over 's'
7648
 
      }// end loop over 'r'
7649
 
      for (unsigned int r = 0; r < 2; r++)
7650
 
      {
7651
 
        for (unsigned int s = 0; s < 2 - r; s++)
7652
 
        {
7653
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
7654
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
7655
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
7656
 
        }// end loop over 's'
7657
 
      }// end loop over 'r'
7658
 
      for (unsigned int r = 0; r < 1; r++)
7659
 
      {
7660
 
        for (unsigned int s = 0; s < 1 - r; s++)
7661
 
        {
7662
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
7663
 
          {
7664
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
7665
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
7666
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
7667
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
7668
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
7669
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
7670
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
7671
 
          }// end loop over 't'
7672
 
        }// end loop over 's'
7673
 
      }// end loop over 'r'
7674
 
      for (unsigned int r = 0; r < 3; r++)
7675
 
      {
7676
 
        for (unsigned int s = 0; s < 3 - r; s++)
7677
 
        {
7678
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
7679
 
          {
7680
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
7681
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
7682
 
          }// end loop over 't'
7683
 
        }// end loop over 's'
7684
 
      }// end loop over 'r'
 
5067
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
5068
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
5069
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
5070
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
5071
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
5072
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
5073
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
5074
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
5075
      basisvalues[0] *= std::sqrt(0.75);
 
5076
      basisvalues[3] *= std::sqrt(1.25);
 
5077
      basisvalues[9] *= std::sqrt(1.75);
 
5078
      basisvalues[2] *= std::sqrt(2.5);
 
5079
      basisvalues[8] *= std::sqrt(3.5);
 
5080
      basisvalues[7] *= std::sqrt(5.25);
 
5081
      basisvalues[1] *= std::sqrt(7.5);
 
5082
      basisvalues[6] *= std::sqrt(10.5);
 
5083
      basisvalues[5] *= std::sqrt(15.75);
 
5084
      basisvalues[4] *= std::sqrt(26.25);
7685
5085
      
7686
5086
      // Table(s) of coefficients.
7687
5087
      static const double coefficients0[10] = \
7873
5273
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
7874
5274
      
7875
5275
      // Declare helper variables.
7876
 
      unsigned int rr = 0;
7877
 
      unsigned int ss = 0;
7878
 
      unsigned int tt = 0;
7879
 
      double tmp5 = 0.0;
7880
 
      double tmp6 = 0.0;
7881
 
      double tmp7 = 0.0;
7882
5276
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
7883
5277
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
7884
5278
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
7888
5282
      // Compute basisvalues.
7889
5283
      basisvalues[0] = 1.0;
7890
5284
      basisvalues[1] = tmp0;
7891
 
      for (unsigned int r = 1; r < 2; r++)
7892
 
      {
7893
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
7894
 
        ss = r*(r + 1)*(r + 2)/6;
7895
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
7896
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
7897
 
      }// end loop over 'r'
7898
 
      for (unsigned int r = 0; r < 2; r++)
7899
 
      {
7900
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
7901
 
        ss = r*(r + 1)*(r + 2)/6;
7902
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
7903
 
      }// end loop over 'r'
7904
 
      for (unsigned int r = 0; r < 1; r++)
7905
 
      {
7906
 
        for (unsigned int s = 1; s < 2 - r; s++)
7907
 
        {
7908
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
7909
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
7910
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
7911
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
7912
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
7913
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
7914
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
7915
 
        }// end loop over 's'
7916
 
      }// end loop over 'r'
7917
 
      for (unsigned int r = 0; r < 2; r++)
7918
 
      {
7919
 
        for (unsigned int s = 0; s < 2 - r; s++)
7920
 
        {
7921
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
7922
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
7923
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
7924
 
        }// end loop over 's'
7925
 
      }// end loop over 'r'
7926
 
      for (unsigned int r = 0; r < 1; r++)
7927
 
      {
7928
 
        for (unsigned int s = 0; s < 1 - r; s++)
7929
 
        {
7930
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
7931
 
          {
7932
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
7933
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
7934
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
7935
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
7936
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
7937
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
7938
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
7939
 
          }// end loop over 't'
7940
 
        }// end loop over 's'
7941
 
      }// end loop over 'r'
7942
 
      for (unsigned int r = 0; r < 3; r++)
7943
 
      {
7944
 
        for (unsigned int s = 0; s < 3 - r; s++)
7945
 
        {
7946
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
7947
 
          {
7948
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
7949
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
7950
 
          }// end loop over 't'
7951
 
        }// end loop over 's'
7952
 
      }// end loop over 'r'
 
5285
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
5286
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
5287
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
5288
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
5289
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
5290
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
5291
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
5292
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
5293
      basisvalues[0] *= std::sqrt(0.75);
 
5294
      basisvalues[3] *= std::sqrt(1.25);
 
5295
      basisvalues[9] *= std::sqrt(1.75);
 
5296
      basisvalues[2] *= std::sqrt(2.5);
 
5297
      basisvalues[8] *= std::sqrt(3.5);
 
5298
      basisvalues[7] *= std::sqrt(5.25);
 
5299
      basisvalues[1] *= std::sqrt(7.5);
 
5300
      basisvalues[6] *= std::sqrt(10.5);
 
5301
      basisvalues[5] *= std::sqrt(15.75);
 
5302
      basisvalues[4] *= std::sqrt(26.25);
7953
5303
      
7954
5304
      // Table(s) of coefficients.
7955
5305
      static const double coefficients0[10] = \
8141
5491
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
8142
5492
      
8143
5493
      // Declare helper variables.
8144
 
      unsigned int rr = 0;
8145
 
      unsigned int ss = 0;
8146
 
      unsigned int tt = 0;
8147
 
      double tmp5 = 0.0;
8148
 
      double tmp6 = 0.0;
8149
 
      double tmp7 = 0.0;
8150
5494
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
8151
5495
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
8152
5496
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
8156
5500
      // Compute basisvalues.
8157
5501
      basisvalues[0] = 1.0;
8158
5502
      basisvalues[1] = tmp0;
8159
 
      for (unsigned int r = 1; r < 2; r++)
8160
 
      {
8161
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
8162
 
        ss = r*(r + 1)*(r + 2)/6;
8163
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
8164
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
8165
 
      }// end loop over 'r'
8166
 
      for (unsigned int r = 0; r < 2; r++)
8167
 
      {
8168
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
8169
 
        ss = r*(r + 1)*(r + 2)/6;
8170
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
8171
 
      }// end loop over 'r'
8172
 
      for (unsigned int r = 0; r < 1; r++)
8173
 
      {
8174
 
        for (unsigned int s = 1; s < 2 - r; s++)
8175
 
        {
8176
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
8177
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
8178
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
8179
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
8180
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
8181
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
8182
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
8183
 
        }// end loop over 's'
8184
 
      }// end loop over 'r'
8185
 
      for (unsigned int r = 0; r < 2; r++)
8186
 
      {
8187
 
        for (unsigned int s = 0; s < 2 - r; s++)
8188
 
        {
8189
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
8190
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
8191
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
8192
 
        }// end loop over 's'
8193
 
      }// end loop over 'r'
8194
 
      for (unsigned int r = 0; r < 1; r++)
8195
 
      {
8196
 
        for (unsigned int s = 0; s < 1 - r; s++)
8197
 
        {
8198
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
8199
 
          {
8200
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
8201
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
8202
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
8203
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
8204
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
8205
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
8206
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
8207
 
          }// end loop over 't'
8208
 
        }// end loop over 's'
8209
 
      }// end loop over 'r'
8210
 
      for (unsigned int r = 0; r < 3; r++)
8211
 
      {
8212
 
        for (unsigned int s = 0; s < 3 - r; s++)
8213
 
        {
8214
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
8215
 
          {
8216
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
8217
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
8218
 
          }// end loop over 't'
8219
 
        }// end loop over 's'
8220
 
      }// end loop over 'r'
 
5503
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
5504
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
5505
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
5506
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
5507
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
5508
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
5509
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
5510
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
5511
      basisvalues[0] *= std::sqrt(0.75);
 
5512
      basisvalues[3] *= std::sqrt(1.25);
 
5513
      basisvalues[9] *= std::sqrt(1.75);
 
5514
      basisvalues[2] *= std::sqrt(2.5);
 
5515
      basisvalues[8] *= std::sqrt(3.5);
 
5516
      basisvalues[7] *= std::sqrt(5.25);
 
5517
      basisvalues[1] *= std::sqrt(7.5);
 
5518
      basisvalues[6] *= std::sqrt(10.5);
 
5519
      basisvalues[5] *= std::sqrt(15.75);
 
5520
      basisvalues[4] *= std::sqrt(26.25);
8221
5521
      
8222
5522
      // Table(s) of coefficients.
8223
5523
      static const double coefficients0[10] = \
8409
5709
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
8410
5710
      
8411
5711
      // Declare helper variables.
8412
 
      unsigned int rr = 0;
8413
 
      unsigned int ss = 0;
8414
 
      unsigned int tt = 0;
8415
 
      double tmp5 = 0.0;
8416
 
      double tmp6 = 0.0;
8417
 
      double tmp7 = 0.0;
8418
5712
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
8419
5713
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
8420
5714
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
8424
5718
      // Compute basisvalues.
8425
5719
      basisvalues[0] = 1.0;
8426
5720
      basisvalues[1] = tmp0;
8427
 
      for (unsigned int r = 1; r < 2; r++)
8428
 
      {
8429
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
8430
 
        ss = r*(r + 1)*(r + 2)/6;
8431
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
8432
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
8433
 
      }// end loop over 'r'
8434
 
      for (unsigned int r = 0; r < 2; r++)
8435
 
      {
8436
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
8437
 
        ss = r*(r + 1)*(r + 2)/6;
8438
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
8439
 
      }// end loop over 'r'
8440
 
      for (unsigned int r = 0; r < 1; r++)
8441
 
      {
8442
 
        for (unsigned int s = 1; s < 2 - r; s++)
8443
 
        {
8444
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
8445
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
8446
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
8447
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
8448
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
8449
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
8450
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
8451
 
        }// end loop over 's'
8452
 
      }// end loop over 'r'
8453
 
      for (unsigned int r = 0; r < 2; r++)
8454
 
      {
8455
 
        for (unsigned int s = 0; s < 2 - r; s++)
8456
 
        {
8457
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
8458
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
8459
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
8460
 
        }// end loop over 's'
8461
 
      }// end loop over 'r'
8462
 
      for (unsigned int r = 0; r < 1; r++)
8463
 
      {
8464
 
        for (unsigned int s = 0; s < 1 - r; s++)
8465
 
        {
8466
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
8467
 
          {
8468
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
8469
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
8470
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
8471
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
8472
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
8473
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
8474
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
8475
 
          }// end loop over 't'
8476
 
        }// end loop over 's'
8477
 
      }// end loop over 'r'
8478
 
      for (unsigned int r = 0; r < 3; r++)
8479
 
      {
8480
 
        for (unsigned int s = 0; s < 3 - r; s++)
8481
 
        {
8482
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
8483
 
          {
8484
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
8485
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
8486
 
          }// end loop over 't'
8487
 
        }// end loop over 's'
8488
 
      }// end loop over 'r'
 
5721
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
5722
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
5723
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
5724
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
5725
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
5726
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
5727
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
5728
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
5729
      basisvalues[0] *= std::sqrt(0.75);
 
5730
      basisvalues[3] *= std::sqrt(1.25);
 
5731
      basisvalues[9] *= std::sqrt(1.75);
 
5732
      basisvalues[2] *= std::sqrt(2.5);
 
5733
      basisvalues[8] *= std::sqrt(3.5);
 
5734
      basisvalues[7] *= std::sqrt(5.25);
 
5735
      basisvalues[1] *= std::sqrt(7.5);
 
5736
      basisvalues[6] *= std::sqrt(10.5);
 
5737
      basisvalues[5] *= std::sqrt(15.75);
 
5738
      basisvalues[4] *= std::sqrt(26.25);
8489
5739
      
8490
5740
      // Table(s) of coefficients.
8491
5741
      static const double coefficients0[10] = \
8677
5927
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
8678
5928
      
8679
5929
      // Declare helper variables.
8680
 
      unsigned int rr = 0;
8681
 
      unsigned int ss = 0;
8682
 
      unsigned int tt = 0;
8683
 
      double tmp5 = 0.0;
8684
 
      double tmp6 = 0.0;
8685
 
      double tmp7 = 0.0;
8686
5930
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
8687
5931
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
8688
5932
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
8692
5936
      // Compute basisvalues.
8693
5937
      basisvalues[0] = 1.0;
8694
5938
      basisvalues[1] = tmp0;
8695
 
      for (unsigned int r = 1; r < 2; r++)
8696
 
      {
8697
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
8698
 
        ss = r*(r + 1)*(r + 2)/6;
8699
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
8700
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
8701
 
      }// end loop over 'r'
8702
 
      for (unsigned int r = 0; r < 2; r++)
8703
 
      {
8704
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
8705
 
        ss = r*(r + 1)*(r + 2)/6;
8706
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
8707
 
      }// end loop over 'r'
8708
 
      for (unsigned int r = 0; r < 1; r++)
8709
 
      {
8710
 
        for (unsigned int s = 1; s < 2 - r; s++)
8711
 
        {
8712
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
8713
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
8714
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
8715
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
8716
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
8717
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
8718
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
8719
 
        }// end loop over 's'
8720
 
      }// end loop over 'r'
8721
 
      for (unsigned int r = 0; r < 2; r++)
8722
 
      {
8723
 
        for (unsigned int s = 0; s < 2 - r; s++)
8724
 
        {
8725
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
8726
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
8727
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
8728
 
        }// end loop over 's'
8729
 
      }// end loop over 'r'
8730
 
      for (unsigned int r = 0; r < 1; r++)
8731
 
      {
8732
 
        for (unsigned int s = 0; s < 1 - r; s++)
8733
 
        {
8734
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
8735
 
          {
8736
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
8737
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
8738
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
8739
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
8740
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
8741
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
8742
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
8743
 
          }// end loop over 't'
8744
 
        }// end loop over 's'
8745
 
      }// end loop over 'r'
8746
 
      for (unsigned int r = 0; r < 3; r++)
8747
 
      {
8748
 
        for (unsigned int s = 0; s < 3 - r; s++)
8749
 
        {
8750
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
8751
 
          {
8752
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
8753
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
8754
 
          }// end loop over 't'
8755
 
        }// end loop over 's'
8756
 
      }// end loop over 'r'
 
5939
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
5940
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
5941
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
5942
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
5943
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
5944
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
5945
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
5946
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
5947
      basisvalues[0] *= std::sqrt(0.75);
 
5948
      basisvalues[3] *= std::sqrt(1.25);
 
5949
      basisvalues[9] *= std::sqrt(1.75);
 
5950
      basisvalues[2] *= std::sqrt(2.5);
 
5951
      basisvalues[8] *= std::sqrt(3.5);
 
5952
      basisvalues[7] *= std::sqrt(5.25);
 
5953
      basisvalues[1] *= std::sqrt(7.5);
 
5954
      basisvalues[6] *= std::sqrt(10.5);
 
5955
      basisvalues[5] *= std::sqrt(15.75);
 
5956
      basisvalues[4] *= std::sqrt(26.25);
8757
5957
      
8758
5958
      // Table(s) of coefficients.
8759
5959
      static const double coefficients0[10] = \
8945
6145
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
8946
6146
      
8947
6147
      // Declare helper variables.
8948
 
      unsigned int rr = 0;
8949
 
      unsigned int ss = 0;
8950
 
      unsigned int tt = 0;
8951
 
      double tmp5 = 0.0;
8952
 
      double tmp6 = 0.0;
8953
 
      double tmp7 = 0.0;
8954
6148
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
8955
6149
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
8956
6150
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
8960
6154
      // Compute basisvalues.
8961
6155
      basisvalues[0] = 1.0;
8962
6156
      basisvalues[1] = tmp0;
8963
 
      for (unsigned int r = 1; r < 2; r++)
8964
 
      {
8965
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
8966
 
        ss = r*(r + 1)*(r + 2)/6;
8967
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
8968
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
8969
 
      }// end loop over 'r'
8970
 
      for (unsigned int r = 0; r < 2; r++)
8971
 
      {
8972
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
8973
 
        ss = r*(r + 1)*(r + 2)/6;
8974
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
8975
 
      }// end loop over 'r'
8976
 
      for (unsigned int r = 0; r < 1; r++)
8977
 
      {
8978
 
        for (unsigned int s = 1; s < 2 - r; s++)
8979
 
        {
8980
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
8981
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
8982
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
8983
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
8984
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
8985
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
8986
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
8987
 
        }// end loop over 's'
8988
 
      }// end loop over 'r'
8989
 
      for (unsigned int r = 0; r < 2; r++)
8990
 
      {
8991
 
        for (unsigned int s = 0; s < 2 - r; s++)
8992
 
        {
8993
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
8994
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
8995
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
8996
 
        }// end loop over 's'
8997
 
      }// end loop over 'r'
8998
 
      for (unsigned int r = 0; r < 1; r++)
8999
 
      {
9000
 
        for (unsigned int s = 0; s < 1 - r; s++)
9001
 
        {
9002
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
9003
 
          {
9004
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
9005
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
9006
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
9007
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
9008
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
9009
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
9010
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
9011
 
          }// end loop over 't'
9012
 
        }// end loop over 's'
9013
 
      }// end loop over 'r'
9014
 
      for (unsigned int r = 0; r < 3; r++)
9015
 
      {
9016
 
        for (unsigned int s = 0; s < 3 - r; s++)
9017
 
        {
9018
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
9019
 
          {
9020
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
9021
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
9022
 
          }// end loop over 't'
9023
 
        }// end loop over 's'
9024
 
      }// end loop over 'r'
 
6157
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
6158
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
6159
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
6160
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
6161
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
6162
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
6163
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
6164
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
6165
      basisvalues[0] *= std::sqrt(0.75);
 
6166
      basisvalues[3] *= std::sqrt(1.25);
 
6167
      basisvalues[9] *= std::sqrt(1.75);
 
6168
      basisvalues[2] *= std::sqrt(2.5);
 
6169
      basisvalues[8] *= std::sqrt(3.5);
 
6170
      basisvalues[7] *= std::sqrt(5.25);
 
6171
      basisvalues[1] *= std::sqrt(7.5);
 
6172
      basisvalues[6] *= std::sqrt(10.5);
 
6173
      basisvalues[5] *= std::sqrt(15.75);
 
6174
      basisvalues[4] *= std::sqrt(26.25);
9025
6175
      
9026
6176
      // Table(s) of coefficients.
9027
6177
      static const double coefficients0[10] = \
9213
6363
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
9214
6364
      
9215
6365
      // Declare helper variables.
9216
 
      unsigned int rr = 0;
9217
 
      unsigned int ss = 0;
9218
 
      unsigned int tt = 0;
9219
 
      double tmp5 = 0.0;
9220
 
      double tmp6 = 0.0;
9221
 
      double tmp7 = 0.0;
9222
6366
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
9223
6367
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
9224
6368
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
9228
6372
      // Compute basisvalues.
9229
6373
      basisvalues[0] = 1.0;
9230
6374
      basisvalues[1] = tmp0;
9231
 
      for (unsigned int r = 1; r < 2; r++)
9232
 
      {
9233
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
9234
 
        ss = r*(r + 1)*(r + 2)/6;
9235
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
9236
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
9237
 
      }// end loop over 'r'
9238
 
      for (unsigned int r = 0; r < 2; r++)
9239
 
      {
9240
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
9241
 
        ss = r*(r + 1)*(r + 2)/6;
9242
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
9243
 
      }// end loop over 'r'
9244
 
      for (unsigned int r = 0; r < 1; r++)
9245
 
      {
9246
 
        for (unsigned int s = 1; s < 2 - r; s++)
9247
 
        {
9248
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
9249
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
9250
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
9251
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
9252
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
9253
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
9254
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
9255
 
        }// end loop over 's'
9256
 
      }// end loop over 'r'
9257
 
      for (unsigned int r = 0; r < 2; r++)
9258
 
      {
9259
 
        for (unsigned int s = 0; s < 2 - r; s++)
9260
 
        {
9261
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
9262
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
9263
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
9264
 
        }// end loop over 's'
9265
 
      }// end loop over 'r'
9266
 
      for (unsigned int r = 0; r < 1; r++)
9267
 
      {
9268
 
        for (unsigned int s = 0; s < 1 - r; s++)
9269
 
        {
9270
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
9271
 
          {
9272
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
9273
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
9274
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
9275
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
9276
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
9277
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
9278
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
9279
 
          }// end loop over 't'
9280
 
        }// end loop over 's'
9281
 
      }// end loop over 'r'
9282
 
      for (unsigned int r = 0; r < 3; r++)
9283
 
      {
9284
 
        for (unsigned int s = 0; s < 3 - r; s++)
9285
 
        {
9286
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
9287
 
          {
9288
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
9289
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
9290
 
          }// end loop over 't'
9291
 
        }// end loop over 's'
9292
 
      }// end loop over 'r'
 
6375
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
6376
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
6377
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
6378
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
6379
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
6380
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
6381
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
6382
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
6383
      basisvalues[0] *= std::sqrt(0.75);
 
6384
      basisvalues[3] *= std::sqrt(1.25);
 
6385
      basisvalues[9] *= std::sqrt(1.75);
 
6386
      basisvalues[2] *= std::sqrt(2.5);
 
6387
      basisvalues[8] *= std::sqrt(3.5);
 
6388
      basisvalues[7] *= std::sqrt(5.25);
 
6389
      basisvalues[1] *= std::sqrt(7.5);
 
6390
      basisvalues[6] *= std::sqrt(10.5);
 
6391
      basisvalues[5] *= std::sqrt(15.75);
 
6392
      basisvalues[4] *= std::sqrt(26.25);
9293
6393
      
9294
6394
      // Table(s) of coefficients.
9295
6395
      static const double coefficients0[10] = \
9481
6581
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
9482
6582
      
9483
6583
      // Declare helper variables.
9484
 
      unsigned int rr = 0;
9485
 
      unsigned int ss = 0;
9486
 
      unsigned int tt = 0;
9487
 
      double tmp5 = 0.0;
9488
 
      double tmp6 = 0.0;
9489
 
      double tmp7 = 0.0;
9490
6584
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
9491
6585
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
9492
6586
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
9496
6590
      // Compute basisvalues.
9497
6591
      basisvalues[0] = 1.0;
9498
6592
      basisvalues[1] = tmp0;
9499
 
      for (unsigned int r = 1; r < 2; r++)
9500
 
      {
9501
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
9502
 
        ss = r*(r + 1)*(r + 2)/6;
9503
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
9504
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
9505
 
      }// end loop over 'r'
9506
 
      for (unsigned int r = 0; r < 2; r++)
9507
 
      {
9508
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
9509
 
        ss = r*(r + 1)*(r + 2)/6;
9510
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
9511
 
      }// end loop over 'r'
9512
 
      for (unsigned int r = 0; r < 1; r++)
9513
 
      {
9514
 
        for (unsigned int s = 1; s < 2 - r; s++)
9515
 
        {
9516
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
9517
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
9518
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
9519
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
9520
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
9521
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
9522
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
9523
 
        }// end loop over 's'
9524
 
      }// end loop over 'r'
9525
 
      for (unsigned int r = 0; r < 2; r++)
9526
 
      {
9527
 
        for (unsigned int s = 0; s < 2 - r; s++)
9528
 
        {
9529
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
9530
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
9531
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
9532
 
        }// end loop over 's'
9533
 
      }// end loop over 'r'
9534
 
      for (unsigned int r = 0; r < 1; r++)
9535
 
      {
9536
 
        for (unsigned int s = 0; s < 1 - r; s++)
9537
 
        {
9538
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
9539
 
          {
9540
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
9541
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
9542
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
9543
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
9544
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
9545
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
9546
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
9547
 
          }// end loop over 't'
9548
 
        }// end loop over 's'
9549
 
      }// end loop over 'r'
9550
 
      for (unsigned int r = 0; r < 3; r++)
9551
 
      {
9552
 
        for (unsigned int s = 0; s < 3 - r; s++)
9553
 
        {
9554
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
9555
 
          {
9556
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
9557
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
9558
 
          }// end loop over 't'
9559
 
        }// end loop over 's'
9560
 
      }// end loop over 'r'
 
6593
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
6594
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
6595
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
6596
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
6597
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
6598
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
6599
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
6600
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
6601
      basisvalues[0] *= std::sqrt(0.75);
 
6602
      basisvalues[3] *= std::sqrt(1.25);
 
6603
      basisvalues[9] *= std::sqrt(1.75);
 
6604
      basisvalues[2] *= std::sqrt(2.5);
 
6605
      basisvalues[8] *= std::sqrt(3.5);
 
6606
      basisvalues[7] *= std::sqrt(5.25);
 
6607
      basisvalues[1] *= std::sqrt(7.5);
 
6608
      basisvalues[6] *= std::sqrt(10.5);
 
6609
      basisvalues[5] *= std::sqrt(15.75);
 
6610
      basisvalues[4] *= std::sqrt(26.25);
9561
6611
      
9562
6612
      // Table(s) of coefficients.
9563
6613
      static const double coefficients0[10] = \
9749
6799
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
9750
6800
      
9751
6801
      // Declare helper variables.
9752
 
      unsigned int rr = 0;
9753
 
      unsigned int ss = 0;
9754
 
      unsigned int tt = 0;
9755
 
      double tmp5 = 0.0;
9756
 
      double tmp6 = 0.0;
9757
 
      double tmp7 = 0.0;
9758
6802
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
9759
6803
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
9760
6804
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
9764
6808
      // Compute basisvalues.
9765
6809
      basisvalues[0] = 1.0;
9766
6810
      basisvalues[1] = tmp0;
9767
 
      for (unsigned int r = 1; r < 2; r++)
9768
 
      {
9769
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
9770
 
        ss = r*(r + 1)*(r + 2)/6;
9771
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
9772
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
9773
 
      }// end loop over 'r'
9774
 
      for (unsigned int r = 0; r < 2; r++)
9775
 
      {
9776
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
9777
 
        ss = r*(r + 1)*(r + 2)/6;
9778
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
9779
 
      }// end loop over 'r'
9780
 
      for (unsigned int r = 0; r < 1; r++)
9781
 
      {
9782
 
        for (unsigned int s = 1; s < 2 - r; s++)
9783
 
        {
9784
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
9785
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
9786
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
9787
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
9788
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
9789
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
9790
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
9791
 
        }// end loop over 's'
9792
 
      }// end loop over 'r'
9793
 
      for (unsigned int r = 0; r < 2; r++)
9794
 
      {
9795
 
        for (unsigned int s = 0; s < 2 - r; s++)
9796
 
        {
9797
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
9798
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
9799
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
9800
 
        }// end loop over 's'
9801
 
      }// end loop over 'r'
9802
 
      for (unsigned int r = 0; r < 1; r++)
9803
 
      {
9804
 
        for (unsigned int s = 0; s < 1 - r; s++)
9805
 
        {
9806
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
9807
 
          {
9808
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
9809
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
9810
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
9811
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
9812
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
9813
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
9814
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
9815
 
          }// end loop over 't'
9816
 
        }// end loop over 's'
9817
 
      }// end loop over 'r'
9818
 
      for (unsigned int r = 0; r < 3; r++)
9819
 
      {
9820
 
        for (unsigned int s = 0; s < 3 - r; s++)
9821
 
        {
9822
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
9823
 
          {
9824
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
9825
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
9826
 
          }// end loop over 't'
9827
 
        }// end loop over 's'
9828
 
      }// end loop over 'r'
 
6811
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
6812
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
6813
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
6814
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
6815
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
6816
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
6817
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
6818
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
6819
      basisvalues[0] *= std::sqrt(0.75);
 
6820
      basisvalues[3] *= std::sqrt(1.25);
 
6821
      basisvalues[9] *= std::sqrt(1.75);
 
6822
      basisvalues[2] *= std::sqrt(2.5);
 
6823
      basisvalues[8] *= std::sqrt(3.5);
 
6824
      basisvalues[7] *= std::sqrt(5.25);
 
6825
      basisvalues[1] *= std::sqrt(7.5);
 
6826
      basisvalues[6] *= std::sqrt(10.5);
 
6827
      basisvalues[5] *= std::sqrt(15.75);
 
6828
      basisvalues[4] *= std::sqrt(26.25);
9829
6829
      
9830
6830
      // Table(s) of coefficients.
9831
6831
      static const double coefficients0[10] = \
10017
7017
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
10018
7018
      
10019
7019
      // Declare helper variables.
10020
 
      unsigned int rr = 0;
10021
 
      unsigned int ss = 0;
10022
 
      unsigned int tt = 0;
10023
 
      double tmp5 = 0.0;
10024
 
      double tmp6 = 0.0;
10025
 
      double tmp7 = 0.0;
10026
7020
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
10027
7021
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
10028
7022
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
10032
7026
      // Compute basisvalues.
10033
7027
      basisvalues[0] = 1.0;
10034
7028
      basisvalues[1] = tmp0;
10035
 
      for (unsigned int r = 1; r < 2; r++)
10036
 
      {
10037
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
10038
 
        ss = r*(r + 1)*(r + 2)/6;
10039
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
10040
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
10041
 
      }// end loop over 'r'
10042
 
      for (unsigned int r = 0; r < 2; r++)
10043
 
      {
10044
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
10045
 
        ss = r*(r + 1)*(r + 2)/6;
10046
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
10047
 
      }// end loop over 'r'
10048
 
      for (unsigned int r = 0; r < 1; r++)
10049
 
      {
10050
 
        for (unsigned int s = 1; s < 2 - r; s++)
10051
 
        {
10052
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
10053
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
10054
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
10055
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
10056
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
10057
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
10058
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
10059
 
        }// end loop over 's'
10060
 
      }// end loop over 'r'
10061
 
      for (unsigned int r = 0; r < 2; r++)
10062
 
      {
10063
 
        for (unsigned int s = 0; s < 2 - r; s++)
10064
 
        {
10065
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
10066
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
10067
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
10068
 
        }// end loop over 's'
10069
 
      }// end loop over 'r'
10070
 
      for (unsigned int r = 0; r < 1; r++)
10071
 
      {
10072
 
        for (unsigned int s = 0; s < 1 - r; s++)
10073
 
        {
10074
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
10075
 
          {
10076
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
10077
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
10078
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
10079
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
10080
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
10081
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
10082
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
10083
 
          }// end loop over 't'
10084
 
        }// end loop over 's'
10085
 
      }// end loop over 'r'
10086
 
      for (unsigned int r = 0; r < 3; r++)
10087
 
      {
10088
 
        for (unsigned int s = 0; s < 3 - r; s++)
10089
 
        {
10090
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
10091
 
          {
10092
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
10093
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
10094
 
          }// end loop over 't'
10095
 
        }// end loop over 's'
10096
 
      }// end loop over 'r'
 
7029
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
7030
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
7031
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
7032
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
7033
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
7034
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
7035
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
7036
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
7037
      basisvalues[0] *= std::sqrt(0.75);
 
7038
      basisvalues[3] *= std::sqrt(1.25);
 
7039
      basisvalues[9] *= std::sqrt(1.75);
 
7040
      basisvalues[2] *= std::sqrt(2.5);
 
7041
      basisvalues[8] *= std::sqrt(3.5);
 
7042
      basisvalues[7] *= std::sqrt(5.25);
 
7043
      basisvalues[1] *= std::sqrt(7.5);
 
7044
      basisvalues[6] *= std::sqrt(10.5);
 
7045
      basisvalues[5] *= std::sqrt(15.75);
 
7046
      basisvalues[4] *= std::sqrt(26.25);
10097
7047
      
10098
7048
      // Table(s) of coefficients.
10099
7049
      static const double coefficients0[10] = \
10285
7235
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
10286
7236
      
10287
7237
      // Declare helper variables.
10288
 
      unsigned int rr = 0;
10289
 
      unsigned int ss = 0;
10290
 
      unsigned int tt = 0;
10291
 
      double tmp5 = 0.0;
10292
 
      double tmp6 = 0.0;
10293
 
      double tmp7 = 0.0;
10294
7238
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
10295
7239
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
10296
7240
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
10300
7244
      // Compute basisvalues.
10301
7245
      basisvalues[0] = 1.0;
10302
7246
      basisvalues[1] = tmp0;
10303
 
      for (unsigned int r = 1; r < 2; r++)
10304
 
      {
10305
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
10306
 
        ss = r*(r + 1)*(r + 2)/6;
10307
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
10308
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
10309
 
      }// end loop over 'r'
10310
 
      for (unsigned int r = 0; r < 2; r++)
10311
 
      {
10312
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
10313
 
        ss = r*(r + 1)*(r + 2)/6;
10314
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
10315
 
      }// end loop over 'r'
10316
 
      for (unsigned int r = 0; r < 1; r++)
10317
 
      {
10318
 
        for (unsigned int s = 1; s < 2 - r; s++)
10319
 
        {
10320
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
10321
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
10322
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
10323
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
10324
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
10325
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
10326
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
10327
 
        }// end loop over 's'
10328
 
      }// end loop over 'r'
10329
 
      for (unsigned int r = 0; r < 2; r++)
10330
 
      {
10331
 
        for (unsigned int s = 0; s < 2 - r; s++)
10332
 
        {
10333
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
10334
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
10335
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
10336
 
        }// end loop over 's'
10337
 
      }// end loop over 'r'
10338
 
      for (unsigned int r = 0; r < 1; r++)
10339
 
      {
10340
 
        for (unsigned int s = 0; s < 1 - r; s++)
10341
 
        {
10342
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
10343
 
          {
10344
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
10345
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
10346
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
10347
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
10348
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
10349
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
10350
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
10351
 
          }// end loop over 't'
10352
 
        }// end loop over 's'
10353
 
      }// end loop over 'r'
10354
 
      for (unsigned int r = 0; r < 3; r++)
10355
 
      {
10356
 
        for (unsigned int s = 0; s < 3 - r; s++)
10357
 
        {
10358
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
10359
 
          {
10360
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
10361
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
10362
 
          }// end loop over 't'
10363
 
        }// end loop over 's'
10364
 
      }// end loop over 'r'
 
7247
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
7248
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
7249
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
7250
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
7251
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
7252
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
7253
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
7254
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
7255
      basisvalues[0] *= std::sqrt(0.75);
 
7256
      basisvalues[3] *= std::sqrt(1.25);
 
7257
      basisvalues[9] *= std::sqrt(1.75);
 
7258
      basisvalues[2] *= std::sqrt(2.5);
 
7259
      basisvalues[8] *= std::sqrt(3.5);
 
7260
      basisvalues[7] *= std::sqrt(5.25);
 
7261
      basisvalues[1] *= std::sqrt(7.5);
 
7262
      basisvalues[6] *= std::sqrt(10.5);
 
7263
      basisvalues[5] *= std::sqrt(15.75);
 
7264
      basisvalues[4] *= std::sqrt(26.25);
10365
7265
      
10366
7266
      // Table(s) of coefficients.
10367
7267
      static const double coefficients0[10] = \
10553
7453
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
10554
7454
      
10555
7455
      // Declare helper variables.
10556
 
      unsigned int rr = 0;
10557
 
      unsigned int ss = 0;
10558
 
      unsigned int tt = 0;
10559
 
      double tmp5 = 0.0;
10560
 
      double tmp6 = 0.0;
10561
 
      double tmp7 = 0.0;
10562
7456
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
10563
7457
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
10564
7458
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
10568
7462
      // Compute basisvalues.
10569
7463
      basisvalues[0] = 1.0;
10570
7464
      basisvalues[1] = tmp0;
10571
 
      for (unsigned int r = 1; r < 2; r++)
10572
 
      {
10573
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
10574
 
        ss = r*(r + 1)*(r + 2)/6;
10575
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
10576
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
10577
 
      }// end loop over 'r'
10578
 
      for (unsigned int r = 0; r < 2; r++)
10579
 
      {
10580
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
10581
 
        ss = r*(r + 1)*(r + 2)/6;
10582
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
10583
 
      }// end loop over 'r'
10584
 
      for (unsigned int r = 0; r < 1; r++)
10585
 
      {
10586
 
        for (unsigned int s = 1; s < 2 - r; s++)
10587
 
        {
10588
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
10589
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
10590
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
10591
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
10592
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
10593
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
10594
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
10595
 
        }// end loop over 's'
10596
 
      }// end loop over 'r'
10597
 
      for (unsigned int r = 0; r < 2; r++)
10598
 
      {
10599
 
        for (unsigned int s = 0; s < 2 - r; s++)
10600
 
        {
10601
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
10602
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
10603
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
10604
 
        }// end loop over 's'
10605
 
      }// end loop over 'r'
10606
 
      for (unsigned int r = 0; r < 1; r++)
10607
 
      {
10608
 
        for (unsigned int s = 0; s < 1 - r; s++)
10609
 
        {
10610
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
10611
 
          {
10612
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
10613
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
10614
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
10615
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
10616
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
10617
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
10618
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
10619
 
          }// end loop over 't'
10620
 
        }// end loop over 's'
10621
 
      }// end loop over 'r'
10622
 
      for (unsigned int r = 0; r < 3; r++)
10623
 
      {
10624
 
        for (unsigned int s = 0; s < 3 - r; s++)
10625
 
        {
10626
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
10627
 
          {
10628
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
10629
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
10630
 
          }// end loop over 't'
10631
 
        }// end loop over 's'
10632
 
      }// end loop over 'r'
 
7465
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
7466
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
7467
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
7468
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
7469
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
7470
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
7471
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
7472
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
7473
      basisvalues[0] *= std::sqrt(0.75);
 
7474
      basisvalues[3] *= std::sqrt(1.25);
 
7475
      basisvalues[9] *= std::sqrt(1.75);
 
7476
      basisvalues[2] *= std::sqrt(2.5);
 
7477
      basisvalues[8] *= std::sqrt(3.5);
 
7478
      basisvalues[7] *= std::sqrt(5.25);
 
7479
      basisvalues[1] *= std::sqrt(7.5);
 
7480
      basisvalues[6] *= std::sqrt(10.5);
 
7481
      basisvalues[5] *= std::sqrt(15.75);
 
7482
      basisvalues[4] *= std::sqrt(26.25);
10633
7483
      
10634
7484
      // Table(s) of coefficients.
10635
7485
      static const double coefficients0[10] = \
10821
7671
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
10822
7672
      
10823
7673
      // Declare helper variables.
10824
 
      unsigned int rr = 0;
10825
 
      unsigned int ss = 0;
10826
 
      unsigned int tt = 0;
10827
 
      double tmp5 = 0.0;
10828
 
      double tmp6 = 0.0;
10829
 
      double tmp7 = 0.0;
10830
7674
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
10831
7675
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
10832
7676
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
10836
7680
      // Compute basisvalues.
10837
7681
      basisvalues[0] = 1.0;
10838
7682
      basisvalues[1] = tmp0;
10839
 
      for (unsigned int r = 1; r < 2; r++)
10840
 
      {
10841
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
10842
 
        ss = r*(r + 1)*(r + 2)/6;
10843
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
10844
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
10845
 
      }// end loop over 'r'
10846
 
      for (unsigned int r = 0; r < 2; r++)
10847
 
      {
10848
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
10849
 
        ss = r*(r + 1)*(r + 2)/6;
10850
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
10851
 
      }// end loop over 'r'
10852
 
      for (unsigned int r = 0; r < 1; r++)
10853
 
      {
10854
 
        for (unsigned int s = 1; s < 2 - r; s++)
10855
 
        {
10856
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
10857
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
10858
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
10859
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
10860
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
10861
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
10862
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
10863
 
        }// end loop over 's'
10864
 
      }// end loop over 'r'
10865
 
      for (unsigned int r = 0; r < 2; r++)
10866
 
      {
10867
 
        for (unsigned int s = 0; s < 2 - r; s++)
10868
 
        {
10869
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
10870
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
10871
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
10872
 
        }// end loop over 's'
10873
 
      }// end loop over 'r'
10874
 
      for (unsigned int r = 0; r < 1; r++)
10875
 
      {
10876
 
        for (unsigned int s = 0; s < 1 - r; s++)
10877
 
        {
10878
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
10879
 
          {
10880
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
10881
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
10882
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
10883
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
10884
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
10885
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
10886
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
10887
 
          }// end loop over 't'
10888
 
        }// end loop over 's'
10889
 
      }// end loop over 'r'
10890
 
      for (unsigned int r = 0; r < 3; r++)
10891
 
      {
10892
 
        for (unsigned int s = 0; s < 3 - r; s++)
10893
 
        {
10894
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
10895
 
          {
10896
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
10897
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
10898
 
          }// end loop over 't'
10899
 
        }// end loop over 's'
10900
 
      }// end loop over 'r'
 
7683
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
7684
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
7685
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
7686
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
7687
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
7688
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
7689
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
7690
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
7691
      basisvalues[0] *= std::sqrt(0.75);
 
7692
      basisvalues[3] *= std::sqrt(1.25);
 
7693
      basisvalues[9] *= std::sqrt(1.75);
 
7694
      basisvalues[2] *= std::sqrt(2.5);
 
7695
      basisvalues[8] *= std::sqrt(3.5);
 
7696
      basisvalues[7] *= std::sqrt(5.25);
 
7697
      basisvalues[1] *= std::sqrt(7.5);
 
7698
      basisvalues[6] *= std::sqrt(10.5);
 
7699
      basisvalues[5] *= std::sqrt(15.75);
 
7700
      basisvalues[4] *= std::sqrt(26.25);
10901
7701
      
10902
7702
      // Table(s) of coefficients.
10903
7703
      static const double coefficients0[10] = \
11089
7889
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
11090
7890
      
11091
7891
      // Declare helper variables.
11092
 
      unsigned int rr = 0;
11093
 
      unsigned int ss = 0;
11094
 
      unsigned int tt = 0;
11095
 
      double tmp5 = 0.0;
11096
 
      double tmp6 = 0.0;
11097
 
      double tmp7 = 0.0;
11098
7892
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
11099
7893
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
11100
7894
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
11104
7898
      // Compute basisvalues.
11105
7899
      basisvalues[0] = 1.0;
11106
7900
      basisvalues[1] = tmp0;
11107
 
      for (unsigned int r = 1; r < 2; r++)
11108
 
      {
11109
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
11110
 
        ss = r*(r + 1)*(r + 2)/6;
11111
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
11112
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
11113
 
      }// end loop over 'r'
11114
 
      for (unsigned int r = 0; r < 2; r++)
11115
 
      {
11116
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
11117
 
        ss = r*(r + 1)*(r + 2)/6;
11118
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
11119
 
      }// end loop over 'r'
11120
 
      for (unsigned int r = 0; r < 1; r++)
11121
 
      {
11122
 
        for (unsigned int s = 1; s < 2 - r; s++)
11123
 
        {
11124
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
11125
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
11126
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
11127
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
11128
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
11129
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
11130
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
11131
 
        }// end loop over 's'
11132
 
      }// end loop over 'r'
11133
 
      for (unsigned int r = 0; r < 2; r++)
11134
 
      {
11135
 
        for (unsigned int s = 0; s < 2 - r; s++)
11136
 
        {
11137
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
11138
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
11139
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
11140
 
        }// end loop over 's'
11141
 
      }// end loop over 'r'
11142
 
      for (unsigned int r = 0; r < 1; r++)
11143
 
      {
11144
 
        for (unsigned int s = 0; s < 1 - r; s++)
11145
 
        {
11146
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
11147
 
          {
11148
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
11149
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
11150
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
11151
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
11152
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
11153
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
11154
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
11155
 
          }// end loop over 't'
11156
 
        }// end loop over 's'
11157
 
      }// end loop over 'r'
11158
 
      for (unsigned int r = 0; r < 3; r++)
11159
 
      {
11160
 
        for (unsigned int s = 0; s < 3 - r; s++)
11161
 
        {
11162
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
11163
 
          {
11164
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
11165
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
11166
 
          }// end loop over 't'
11167
 
        }// end loop over 's'
11168
 
      }// end loop over 'r'
 
7901
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
7902
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
7903
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
7904
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
7905
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
7906
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
7907
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
7908
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
7909
      basisvalues[0] *= std::sqrt(0.75);
 
7910
      basisvalues[3] *= std::sqrt(1.25);
 
7911
      basisvalues[9] *= std::sqrt(1.75);
 
7912
      basisvalues[2] *= std::sqrt(2.5);
 
7913
      basisvalues[8] *= std::sqrt(3.5);
 
7914
      basisvalues[7] *= std::sqrt(5.25);
 
7915
      basisvalues[1] *= std::sqrt(7.5);
 
7916
      basisvalues[6] *= std::sqrt(10.5);
 
7917
      basisvalues[5] *= std::sqrt(15.75);
 
7918
      basisvalues[4] *= std::sqrt(26.25);
11169
7919
      
11170
7920
      // Table(s) of coefficients.
11171
7921
      static const double coefficients0[10] = \
11357
8107
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
11358
8108
      
11359
8109
      // Declare helper variables.
11360
 
      unsigned int rr = 0;
11361
 
      unsigned int ss = 0;
11362
 
      unsigned int tt = 0;
11363
 
      double tmp5 = 0.0;
11364
 
      double tmp6 = 0.0;
11365
 
      double tmp7 = 0.0;
11366
8110
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
11367
8111
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
11368
8112
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
11372
8116
      // Compute basisvalues.
11373
8117
      basisvalues[0] = 1.0;
11374
8118
      basisvalues[1] = tmp0;
11375
 
      for (unsigned int r = 1; r < 2; r++)
11376
 
      {
11377
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
11378
 
        ss = r*(r + 1)*(r + 2)/6;
11379
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
11380
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
11381
 
      }// end loop over 'r'
11382
 
      for (unsigned int r = 0; r < 2; r++)
11383
 
      {
11384
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
11385
 
        ss = r*(r + 1)*(r + 2)/6;
11386
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
11387
 
      }// end loop over 'r'
11388
 
      for (unsigned int r = 0; r < 1; r++)
11389
 
      {
11390
 
        for (unsigned int s = 1; s < 2 - r; s++)
11391
 
        {
11392
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
11393
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
11394
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
11395
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
11396
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
11397
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
11398
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
11399
 
        }// end loop over 's'
11400
 
      }// end loop over 'r'
11401
 
      for (unsigned int r = 0; r < 2; r++)
11402
 
      {
11403
 
        for (unsigned int s = 0; s < 2 - r; s++)
11404
 
        {
11405
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
11406
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
11407
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
11408
 
        }// end loop over 's'
11409
 
      }// end loop over 'r'
11410
 
      for (unsigned int r = 0; r < 1; r++)
11411
 
      {
11412
 
        for (unsigned int s = 0; s < 1 - r; s++)
11413
 
        {
11414
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
11415
 
          {
11416
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
11417
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
11418
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
11419
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
11420
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
11421
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
11422
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
11423
 
          }// end loop over 't'
11424
 
        }// end loop over 's'
11425
 
      }// end loop over 'r'
11426
 
      for (unsigned int r = 0; r < 3; r++)
11427
 
      {
11428
 
        for (unsigned int s = 0; s < 3 - r; s++)
11429
 
        {
11430
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
11431
 
          {
11432
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
11433
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
11434
 
          }// end loop over 't'
11435
 
        }// end loop over 's'
11436
 
      }// end loop over 'r'
 
8119
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
8120
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
8121
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
8122
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
8123
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
8124
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
8125
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
8126
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
8127
      basisvalues[0] *= std::sqrt(0.75);
 
8128
      basisvalues[3] *= std::sqrt(1.25);
 
8129
      basisvalues[9] *= std::sqrt(1.75);
 
8130
      basisvalues[2] *= std::sqrt(2.5);
 
8131
      basisvalues[8] *= std::sqrt(3.5);
 
8132
      basisvalues[7] *= std::sqrt(5.25);
 
8133
      basisvalues[1] *= std::sqrt(7.5);
 
8134
      basisvalues[6] *= std::sqrt(10.5);
 
8135
      basisvalues[5] *= std::sqrt(15.75);
 
8136
      basisvalues[4] *= std::sqrt(26.25);
11437
8137
      
11438
8138
      // Table(s) of coefficients.
11439
8139
      static const double coefficients0[10] = \
11625
8325
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
11626
8326
      
11627
8327
      // Declare helper variables.
11628
 
      unsigned int rr = 0;
11629
 
      unsigned int ss = 0;
11630
 
      unsigned int tt = 0;
11631
 
      double tmp5 = 0.0;
11632
 
      double tmp6 = 0.0;
11633
 
      double tmp7 = 0.0;
11634
8328
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
11635
8329
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
11636
8330
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
11640
8334
      // Compute basisvalues.
11641
8335
      basisvalues[0] = 1.0;
11642
8336
      basisvalues[1] = tmp0;
11643
 
      for (unsigned int r = 1; r < 2; r++)
11644
 
      {
11645
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
11646
 
        ss = r*(r + 1)*(r + 2)/6;
11647
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
11648
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
11649
 
      }// end loop over 'r'
11650
 
      for (unsigned int r = 0; r < 2; r++)
11651
 
      {
11652
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
11653
 
        ss = r*(r + 1)*(r + 2)/6;
11654
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
11655
 
      }// end loop over 'r'
11656
 
      for (unsigned int r = 0; r < 1; r++)
11657
 
      {
11658
 
        for (unsigned int s = 1; s < 2 - r; s++)
11659
 
        {
11660
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
11661
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
11662
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
11663
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
11664
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
11665
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
11666
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
11667
 
        }// end loop over 's'
11668
 
      }// end loop over 'r'
11669
 
      for (unsigned int r = 0; r < 2; r++)
11670
 
      {
11671
 
        for (unsigned int s = 0; s < 2 - r; s++)
11672
 
        {
11673
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
11674
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
11675
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
11676
 
        }// end loop over 's'
11677
 
      }// end loop over 'r'
11678
 
      for (unsigned int r = 0; r < 1; r++)
11679
 
      {
11680
 
        for (unsigned int s = 0; s < 1 - r; s++)
11681
 
        {
11682
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
11683
 
          {
11684
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
11685
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
11686
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
11687
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
11688
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
11689
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
11690
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
11691
 
          }// end loop over 't'
11692
 
        }// end loop over 's'
11693
 
      }// end loop over 'r'
11694
 
      for (unsigned int r = 0; r < 3; r++)
11695
 
      {
11696
 
        for (unsigned int s = 0; s < 3 - r; s++)
11697
 
        {
11698
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
11699
 
          {
11700
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
11701
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
11702
 
          }// end loop over 't'
11703
 
        }// end loop over 's'
11704
 
      }// end loop over 'r'
 
8337
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
8338
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
8339
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
8340
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
8341
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
8342
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
8343
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
8344
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
8345
      basisvalues[0] *= std::sqrt(0.75);
 
8346
      basisvalues[3] *= std::sqrt(1.25);
 
8347
      basisvalues[9] *= std::sqrt(1.75);
 
8348
      basisvalues[2] *= std::sqrt(2.5);
 
8349
      basisvalues[8] *= std::sqrt(3.5);
 
8350
      basisvalues[7] *= std::sqrt(5.25);
 
8351
      basisvalues[1] *= std::sqrt(7.5);
 
8352
      basisvalues[6] *= std::sqrt(10.5);
 
8353
      basisvalues[5] *= std::sqrt(15.75);
 
8354
      basisvalues[4] *= std::sqrt(26.25);
11705
8355
      
11706
8356
      // Table(s) of coefficients.
11707
8357
      static const double coefficients0[10] = \
11893
8543
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
11894
8544
      
11895
8545
      // Declare helper variables.
11896
 
      unsigned int rr = 0;
11897
 
      unsigned int ss = 0;
11898
 
      unsigned int tt = 0;
11899
 
      double tmp5 = 0.0;
11900
 
      double tmp6 = 0.0;
11901
 
      double tmp7 = 0.0;
11902
8546
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
11903
8547
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
11904
8548
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
11908
8552
      // Compute basisvalues.
11909
8553
      basisvalues[0] = 1.0;
11910
8554
      basisvalues[1] = tmp0;
11911
 
      for (unsigned int r = 1; r < 2; r++)
11912
 
      {
11913
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
11914
 
        ss = r*(r + 1)*(r + 2)/6;
11915
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
11916
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
11917
 
      }// end loop over 'r'
11918
 
      for (unsigned int r = 0; r < 2; r++)
11919
 
      {
11920
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
11921
 
        ss = r*(r + 1)*(r + 2)/6;
11922
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
11923
 
      }// end loop over 'r'
11924
 
      for (unsigned int r = 0; r < 1; r++)
11925
 
      {
11926
 
        for (unsigned int s = 1; s < 2 - r; s++)
11927
 
        {
11928
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
11929
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
11930
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
11931
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
11932
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
11933
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
11934
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
11935
 
        }// end loop over 's'
11936
 
      }// end loop over 'r'
11937
 
      for (unsigned int r = 0; r < 2; r++)
11938
 
      {
11939
 
        for (unsigned int s = 0; s < 2 - r; s++)
11940
 
        {
11941
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
11942
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
11943
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
11944
 
        }// end loop over 's'
11945
 
      }// end loop over 'r'
11946
 
      for (unsigned int r = 0; r < 1; r++)
11947
 
      {
11948
 
        for (unsigned int s = 0; s < 1 - r; s++)
11949
 
        {
11950
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
11951
 
          {
11952
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
11953
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
11954
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
11955
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
11956
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
11957
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
11958
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
11959
 
          }// end loop over 't'
11960
 
        }// end loop over 's'
11961
 
      }// end loop over 'r'
11962
 
      for (unsigned int r = 0; r < 3; r++)
11963
 
      {
11964
 
        for (unsigned int s = 0; s < 3 - r; s++)
11965
 
        {
11966
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
11967
 
          {
11968
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
11969
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
11970
 
          }// end loop over 't'
11971
 
        }// end loop over 's'
11972
 
      }// end loop over 'r'
 
8555
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
8556
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
8557
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
8558
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
8559
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
8560
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
8561
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
8562
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
8563
      basisvalues[0] *= std::sqrt(0.75);
 
8564
      basisvalues[3] *= std::sqrt(1.25);
 
8565
      basisvalues[9] *= std::sqrt(1.75);
 
8566
      basisvalues[2] *= std::sqrt(2.5);
 
8567
      basisvalues[8] *= std::sqrt(3.5);
 
8568
      basisvalues[7] *= std::sqrt(5.25);
 
8569
      basisvalues[1] *= std::sqrt(7.5);
 
8570
      basisvalues[6] *= std::sqrt(10.5);
 
8571
      basisvalues[5] *= std::sqrt(15.75);
 
8572
      basisvalues[4] *= std::sqrt(26.25);
11973
8573
      
11974
8574
      // Table(s) of coefficients.
11975
8575
      static const double coefficients0[10] = \
12161
8761
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
12162
8762
      
12163
8763
      // Declare helper variables.
12164
 
      unsigned int rr = 0;
12165
 
      unsigned int ss = 0;
12166
 
      unsigned int tt = 0;
12167
 
      double tmp5 = 0.0;
12168
 
      double tmp6 = 0.0;
12169
 
      double tmp7 = 0.0;
12170
8764
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
12171
8765
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
12172
8766
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
12176
8770
      // Compute basisvalues.
12177
8771
      basisvalues[0] = 1.0;
12178
8772
      basisvalues[1] = tmp0;
12179
 
      for (unsigned int r = 1; r < 2; r++)
12180
 
      {
12181
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
12182
 
        ss = r*(r + 1)*(r + 2)/6;
12183
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
12184
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
12185
 
      }// end loop over 'r'
12186
 
      for (unsigned int r = 0; r < 2; r++)
12187
 
      {
12188
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
12189
 
        ss = r*(r + 1)*(r + 2)/6;
12190
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
12191
 
      }// end loop over 'r'
12192
 
      for (unsigned int r = 0; r < 1; r++)
12193
 
      {
12194
 
        for (unsigned int s = 1; s < 2 - r; s++)
12195
 
        {
12196
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
12197
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
12198
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
12199
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
12200
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
12201
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
12202
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
12203
 
        }// end loop over 's'
12204
 
      }// end loop over 'r'
12205
 
      for (unsigned int r = 0; r < 2; r++)
12206
 
      {
12207
 
        for (unsigned int s = 0; s < 2 - r; s++)
12208
 
        {
12209
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
12210
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
12211
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
12212
 
        }// end loop over 's'
12213
 
      }// end loop over 'r'
12214
 
      for (unsigned int r = 0; r < 1; r++)
12215
 
      {
12216
 
        for (unsigned int s = 0; s < 1 - r; s++)
12217
 
        {
12218
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
12219
 
          {
12220
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
12221
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
12222
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
12223
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
12224
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
12225
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
12226
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
12227
 
          }// end loop over 't'
12228
 
        }// end loop over 's'
12229
 
      }// end loop over 'r'
12230
 
      for (unsigned int r = 0; r < 3; r++)
12231
 
      {
12232
 
        for (unsigned int s = 0; s < 3 - r; s++)
12233
 
        {
12234
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
12235
 
          {
12236
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
12237
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
12238
 
          }// end loop over 't'
12239
 
        }// end loop over 's'
12240
 
      }// end loop over 'r'
 
8773
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
8774
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
8775
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
8776
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
8777
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
8778
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
8779
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
8780
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
8781
      basisvalues[0] *= std::sqrt(0.75);
 
8782
      basisvalues[3] *= std::sqrt(1.25);
 
8783
      basisvalues[9] *= std::sqrt(1.75);
 
8784
      basisvalues[2] *= std::sqrt(2.5);
 
8785
      basisvalues[8] *= std::sqrt(3.5);
 
8786
      basisvalues[7] *= std::sqrt(5.25);
 
8787
      basisvalues[1] *= std::sqrt(7.5);
 
8788
      basisvalues[6] *= std::sqrt(10.5);
 
8789
      basisvalues[5] *= std::sqrt(15.75);
 
8790
      basisvalues[4] *= std::sqrt(26.25);
12241
8791
      
12242
8792
      // Table(s) of coefficients.
12243
8793
      static const double coefficients0[10] = \
12429
8979
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
12430
8980
      
12431
8981
      // Declare helper variables.
12432
 
      unsigned int rr = 0;
12433
 
      unsigned int ss = 0;
12434
 
      unsigned int tt = 0;
12435
 
      double tmp5 = 0.0;
12436
 
      double tmp6 = 0.0;
12437
 
      double tmp7 = 0.0;
12438
8982
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
12439
8983
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
12440
8984
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
12444
8988
      // Compute basisvalues.
12445
8989
      basisvalues[0] = 1.0;
12446
8990
      basisvalues[1] = tmp0;
12447
 
      for (unsigned int r = 1; r < 2; r++)
12448
 
      {
12449
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
12450
 
        ss = r*(r + 1)*(r + 2)/6;
12451
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
12452
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
12453
 
      }// end loop over 'r'
12454
 
      for (unsigned int r = 0; r < 2; r++)
12455
 
      {
12456
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
12457
 
        ss = r*(r + 1)*(r + 2)/6;
12458
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
12459
 
      }// end loop over 'r'
12460
 
      for (unsigned int r = 0; r < 1; r++)
12461
 
      {
12462
 
        for (unsigned int s = 1; s < 2 - r; s++)
12463
 
        {
12464
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
12465
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
12466
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
12467
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
12468
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
12469
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
12470
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
12471
 
        }// end loop over 's'
12472
 
      }// end loop over 'r'
12473
 
      for (unsigned int r = 0; r < 2; r++)
12474
 
      {
12475
 
        for (unsigned int s = 0; s < 2 - r; s++)
12476
 
        {
12477
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
12478
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
12479
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
12480
 
        }// end loop over 's'
12481
 
      }// end loop over 'r'
12482
 
      for (unsigned int r = 0; r < 1; r++)
12483
 
      {
12484
 
        for (unsigned int s = 0; s < 1 - r; s++)
12485
 
        {
12486
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
12487
 
          {
12488
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
12489
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
12490
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
12491
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
12492
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
12493
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
12494
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
12495
 
          }// end loop over 't'
12496
 
        }// end loop over 's'
12497
 
      }// end loop over 'r'
12498
 
      for (unsigned int r = 0; r < 3; r++)
12499
 
      {
12500
 
        for (unsigned int s = 0; s < 3 - r; s++)
12501
 
        {
12502
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
12503
 
          {
12504
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
12505
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
12506
 
          }// end loop over 't'
12507
 
        }// end loop over 's'
12508
 
      }// end loop over 'r'
 
8991
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
8992
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
8993
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
8994
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
8995
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
8996
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
8997
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
8998
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
8999
      basisvalues[0] *= std::sqrt(0.75);
 
9000
      basisvalues[3] *= std::sqrt(1.25);
 
9001
      basisvalues[9] *= std::sqrt(1.75);
 
9002
      basisvalues[2] *= std::sqrt(2.5);
 
9003
      basisvalues[8] *= std::sqrt(3.5);
 
9004
      basisvalues[7] *= std::sqrt(5.25);
 
9005
      basisvalues[1] *= std::sqrt(7.5);
 
9006
      basisvalues[6] *= std::sqrt(10.5);
 
9007
      basisvalues[5] *= std::sqrt(15.75);
 
9008
      basisvalues[4] *= std::sqrt(26.25);
12509
9009
      
12510
9010
      // Table(s) of coefficients.
12511
9011
      static const double coefficients0[10] = \
12697
9197
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
12698
9198
      
12699
9199
      // Declare helper variables.
12700
 
      unsigned int rr = 0;
12701
 
      unsigned int ss = 0;
12702
 
      unsigned int tt = 0;
12703
 
      double tmp5 = 0.0;
12704
 
      double tmp6 = 0.0;
12705
 
      double tmp7 = 0.0;
12706
9200
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
12707
9201
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
12708
9202
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
12712
9206
      // Compute basisvalues.
12713
9207
      basisvalues[0] = 1.0;
12714
9208
      basisvalues[1] = tmp0;
12715
 
      for (unsigned int r = 1; r < 2; r++)
12716
 
      {
12717
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
12718
 
        ss = r*(r + 1)*(r + 2)/6;
12719
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
12720
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
12721
 
      }// end loop over 'r'
12722
 
      for (unsigned int r = 0; r < 2; r++)
12723
 
      {
12724
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
12725
 
        ss = r*(r + 1)*(r + 2)/6;
12726
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
12727
 
      }// end loop over 'r'
12728
 
      for (unsigned int r = 0; r < 1; r++)
12729
 
      {
12730
 
        for (unsigned int s = 1; s < 2 - r; s++)
12731
 
        {
12732
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
12733
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
12734
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
12735
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
12736
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
12737
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
12738
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
12739
 
        }// end loop over 's'
12740
 
      }// end loop over 'r'
12741
 
      for (unsigned int r = 0; r < 2; r++)
12742
 
      {
12743
 
        for (unsigned int s = 0; s < 2 - r; s++)
12744
 
        {
12745
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
12746
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
12747
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
12748
 
        }// end loop over 's'
12749
 
      }// end loop over 'r'
12750
 
      for (unsigned int r = 0; r < 1; r++)
12751
 
      {
12752
 
        for (unsigned int s = 0; s < 1 - r; s++)
12753
 
        {
12754
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
12755
 
          {
12756
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
12757
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
12758
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
12759
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
12760
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
12761
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
12762
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
12763
 
          }// end loop over 't'
12764
 
        }// end loop over 's'
12765
 
      }// end loop over 'r'
12766
 
      for (unsigned int r = 0; r < 3; r++)
12767
 
      {
12768
 
        for (unsigned int s = 0; s < 3 - r; s++)
12769
 
        {
12770
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
12771
 
          {
12772
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
12773
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
12774
 
          }// end loop over 't'
12775
 
        }// end loop over 's'
12776
 
      }// end loop over 'r'
 
9209
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
9210
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
9211
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
9212
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
9213
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
9214
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
9215
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
9216
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
9217
      basisvalues[0] *= std::sqrt(0.75);
 
9218
      basisvalues[3] *= std::sqrt(1.25);
 
9219
      basisvalues[9] *= std::sqrt(1.75);
 
9220
      basisvalues[2] *= std::sqrt(2.5);
 
9221
      basisvalues[8] *= std::sqrt(3.5);
 
9222
      basisvalues[7] *= std::sqrt(5.25);
 
9223
      basisvalues[1] *= std::sqrt(7.5);
 
9224
      basisvalues[6] *= std::sqrt(10.5);
 
9225
      basisvalues[5] *= std::sqrt(15.75);
 
9226
      basisvalues[4] *= std::sqrt(26.25);
12777
9227
      
12778
9228
      // Table(s) of coefficients.
12779
9229
      static const double coefficients0[10] = \
12965
9415
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
12966
9416
      
12967
9417
      // Declare helper variables.
12968
 
      unsigned int rr = 0;
12969
 
      unsigned int ss = 0;
12970
 
      unsigned int tt = 0;
12971
 
      double tmp5 = 0.0;
12972
 
      double tmp6 = 0.0;
12973
 
      double tmp7 = 0.0;
12974
9418
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
12975
9419
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
12976
9420
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
12980
9424
      // Compute basisvalues.
12981
9425
      basisvalues[0] = 1.0;
12982
9426
      basisvalues[1] = tmp0;
12983
 
      for (unsigned int r = 1; r < 2; r++)
12984
 
      {
12985
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
12986
 
        ss = r*(r + 1)*(r + 2)/6;
12987
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
12988
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
12989
 
      }// end loop over 'r'
12990
 
      for (unsigned int r = 0; r < 2; r++)
12991
 
      {
12992
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
12993
 
        ss = r*(r + 1)*(r + 2)/6;
12994
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
12995
 
      }// end loop over 'r'
12996
 
      for (unsigned int r = 0; r < 1; r++)
12997
 
      {
12998
 
        for (unsigned int s = 1; s < 2 - r; s++)
12999
 
        {
13000
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
13001
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
13002
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
13003
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
13004
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
13005
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
13006
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
13007
 
        }// end loop over 's'
13008
 
      }// end loop over 'r'
13009
 
      for (unsigned int r = 0; r < 2; r++)
13010
 
      {
13011
 
        for (unsigned int s = 0; s < 2 - r; s++)
13012
 
        {
13013
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
13014
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
13015
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
13016
 
        }// end loop over 's'
13017
 
      }// end loop over 'r'
13018
 
      for (unsigned int r = 0; r < 1; r++)
13019
 
      {
13020
 
        for (unsigned int s = 0; s < 1 - r; s++)
13021
 
        {
13022
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
13023
 
          {
13024
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
13025
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
13026
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
13027
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
13028
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
13029
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
13030
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
13031
 
          }// end loop over 't'
13032
 
        }// end loop over 's'
13033
 
      }// end loop over 'r'
13034
 
      for (unsigned int r = 0; r < 3; r++)
13035
 
      {
13036
 
        for (unsigned int s = 0; s < 3 - r; s++)
13037
 
        {
13038
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
13039
 
          {
13040
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
13041
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
13042
 
          }// end loop over 't'
13043
 
        }// end loop over 's'
13044
 
      }// end loop over 'r'
 
9427
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
9428
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
9429
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
9430
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
9431
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
9432
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
9433
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
9434
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
9435
      basisvalues[0] *= std::sqrt(0.75);
 
9436
      basisvalues[3] *= std::sqrt(1.25);
 
9437
      basisvalues[9] *= std::sqrt(1.75);
 
9438
      basisvalues[2] *= std::sqrt(2.5);
 
9439
      basisvalues[8] *= std::sqrt(3.5);
 
9440
      basisvalues[7] *= std::sqrt(5.25);
 
9441
      basisvalues[1] *= std::sqrt(7.5);
 
9442
      basisvalues[6] *= std::sqrt(10.5);
 
9443
      basisvalues[5] *= std::sqrt(15.75);
 
9444
      basisvalues[4] *= std::sqrt(26.25);
13045
9445
      
13046
9446
      // Table(s) of coefficients.
13047
9447
      static const double coefficients0[10] = \
13233
9633
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
13234
9634
      
13235
9635
      // Declare helper variables.
13236
 
      unsigned int rr = 0;
13237
 
      unsigned int ss = 0;
13238
 
      unsigned int tt = 0;
13239
 
      double tmp5 = 0.0;
13240
 
      double tmp6 = 0.0;
13241
 
      double tmp7 = 0.0;
13242
9636
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
13243
9637
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
13244
9638
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
13248
9642
      // Compute basisvalues.
13249
9643
      basisvalues[0] = 1.0;
13250
9644
      basisvalues[1] = tmp0;
13251
 
      for (unsigned int r = 1; r < 2; r++)
13252
 
      {
13253
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
13254
 
        ss = r*(r + 1)*(r + 2)/6;
13255
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
13256
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
13257
 
      }// end loop over 'r'
13258
 
      for (unsigned int r = 0; r < 2; r++)
13259
 
      {
13260
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
13261
 
        ss = r*(r + 1)*(r + 2)/6;
13262
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
13263
 
      }// end loop over 'r'
13264
 
      for (unsigned int r = 0; r < 1; r++)
13265
 
      {
13266
 
        for (unsigned int s = 1; s < 2 - r; s++)
13267
 
        {
13268
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
13269
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
13270
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
13271
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
13272
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
13273
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
13274
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
13275
 
        }// end loop over 's'
13276
 
      }// end loop over 'r'
13277
 
      for (unsigned int r = 0; r < 2; r++)
13278
 
      {
13279
 
        for (unsigned int s = 0; s < 2 - r; s++)
13280
 
        {
13281
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
13282
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
13283
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
13284
 
        }// end loop over 's'
13285
 
      }// end loop over 'r'
13286
 
      for (unsigned int r = 0; r < 1; r++)
13287
 
      {
13288
 
        for (unsigned int s = 0; s < 1 - r; s++)
13289
 
        {
13290
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
13291
 
          {
13292
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
13293
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
13294
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
13295
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
13296
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
13297
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
13298
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
13299
 
          }// end loop over 't'
13300
 
        }// end loop over 's'
13301
 
      }// end loop over 'r'
13302
 
      for (unsigned int r = 0; r < 3; r++)
13303
 
      {
13304
 
        for (unsigned int s = 0; s < 3 - r; s++)
13305
 
        {
13306
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
13307
 
          {
13308
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
13309
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
13310
 
          }// end loop over 't'
13311
 
        }// end loop over 's'
13312
 
      }// end loop over 'r'
 
9645
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
9646
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
9647
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
9648
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
9649
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
9650
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
9651
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
9652
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
9653
      basisvalues[0] *= std::sqrt(0.75);
 
9654
      basisvalues[3] *= std::sqrt(1.25);
 
9655
      basisvalues[9] *= std::sqrt(1.75);
 
9656
      basisvalues[2] *= std::sqrt(2.5);
 
9657
      basisvalues[8] *= std::sqrt(3.5);
 
9658
      basisvalues[7] *= std::sqrt(5.25);
 
9659
      basisvalues[1] *= std::sqrt(7.5);
 
9660
      basisvalues[6] *= std::sqrt(10.5);
 
9661
      basisvalues[5] *= std::sqrt(15.75);
 
9662
      basisvalues[4] *= std::sqrt(26.25);
13313
9663
      
13314
9664
      // Table(s) of coefficients.
13315
9665
      static const double coefficients0[10] = \
13501
9851
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
13502
9852
      
13503
9853
      // Declare helper variables.
13504
 
      unsigned int rr = 0;
13505
 
      unsigned int ss = 0;
13506
 
      unsigned int tt = 0;
13507
 
      double tmp5 = 0.0;
13508
 
      double tmp6 = 0.0;
13509
 
      double tmp7 = 0.0;
13510
9854
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
13511
9855
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
13512
9856
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
13516
9860
      // Compute basisvalues.
13517
9861
      basisvalues[0] = 1.0;
13518
9862
      basisvalues[1] = tmp0;
13519
 
      for (unsigned int r = 1; r < 2; r++)
13520
 
      {
13521
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
13522
 
        ss = r*(r + 1)*(r + 2)/6;
13523
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
13524
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
13525
 
      }// end loop over 'r'
13526
 
      for (unsigned int r = 0; r < 2; r++)
13527
 
      {
13528
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
13529
 
        ss = r*(r + 1)*(r + 2)/6;
13530
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
13531
 
      }// end loop over 'r'
13532
 
      for (unsigned int r = 0; r < 1; r++)
13533
 
      {
13534
 
        for (unsigned int s = 1; s < 2 - r; s++)
13535
 
        {
13536
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
13537
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
13538
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
13539
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
13540
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
13541
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
13542
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
13543
 
        }// end loop over 's'
13544
 
      }// end loop over 'r'
13545
 
      for (unsigned int r = 0; r < 2; r++)
13546
 
      {
13547
 
        for (unsigned int s = 0; s < 2 - r; s++)
13548
 
        {
13549
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
13550
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
13551
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
13552
 
        }// end loop over 's'
13553
 
      }// end loop over 'r'
13554
 
      for (unsigned int r = 0; r < 1; r++)
13555
 
      {
13556
 
        for (unsigned int s = 0; s < 1 - r; s++)
13557
 
        {
13558
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
13559
 
          {
13560
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
13561
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
13562
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
13563
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
13564
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
13565
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
13566
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
13567
 
          }// end loop over 't'
13568
 
        }// end loop over 's'
13569
 
      }// end loop over 'r'
13570
 
      for (unsigned int r = 0; r < 3; r++)
13571
 
      {
13572
 
        for (unsigned int s = 0; s < 3 - r; s++)
13573
 
        {
13574
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
13575
 
          {
13576
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
13577
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
13578
 
          }// end loop over 't'
13579
 
        }// end loop over 's'
13580
 
      }// end loop over 'r'
 
9863
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
9864
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
9865
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
9866
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
9867
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
9868
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
9869
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
9870
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
9871
      basisvalues[0] *= std::sqrt(0.75);
 
9872
      basisvalues[3] *= std::sqrt(1.25);
 
9873
      basisvalues[9] *= std::sqrt(1.75);
 
9874
      basisvalues[2] *= std::sqrt(2.5);
 
9875
      basisvalues[8] *= std::sqrt(3.5);
 
9876
      basisvalues[7] *= std::sqrt(5.25);
 
9877
      basisvalues[1] *= std::sqrt(7.5);
 
9878
      basisvalues[6] *= std::sqrt(10.5);
 
9879
      basisvalues[5] *= std::sqrt(15.75);
 
9880
      basisvalues[4] *= std::sqrt(26.25);
13581
9881
      
13582
9882
      // Table(s) of coefficients.
13583
9883
      static const double coefficients0[10] = \
13769
10069
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
13770
10070
      
13771
10071
      // Declare helper variables.
13772
 
      unsigned int rr = 0;
13773
 
      unsigned int ss = 0;
13774
 
      unsigned int tt = 0;
13775
 
      double tmp5 = 0.0;
13776
 
      double tmp6 = 0.0;
13777
 
      double tmp7 = 0.0;
13778
10072
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
13779
10073
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
13780
10074
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
13784
10078
      // Compute basisvalues.
13785
10079
      basisvalues[0] = 1.0;
13786
10080
      basisvalues[1] = tmp0;
13787
 
      for (unsigned int r = 1; r < 2; r++)
13788
 
      {
13789
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
13790
 
        ss = r*(r + 1)*(r + 2)/6;
13791
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
13792
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
13793
 
      }// end loop over 'r'
13794
 
      for (unsigned int r = 0; r < 2; r++)
13795
 
      {
13796
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
13797
 
        ss = r*(r + 1)*(r + 2)/6;
13798
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
13799
 
      }// end loop over 'r'
13800
 
      for (unsigned int r = 0; r < 1; r++)
13801
 
      {
13802
 
        for (unsigned int s = 1; s < 2 - r; s++)
13803
 
        {
13804
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
13805
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
13806
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
13807
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
13808
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
13809
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
13810
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
13811
 
        }// end loop over 's'
13812
 
      }// end loop over 'r'
13813
 
      for (unsigned int r = 0; r < 2; r++)
13814
 
      {
13815
 
        for (unsigned int s = 0; s < 2 - r; s++)
13816
 
        {
13817
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
13818
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
13819
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
13820
 
        }// end loop over 's'
13821
 
      }// end loop over 'r'
13822
 
      for (unsigned int r = 0; r < 1; r++)
13823
 
      {
13824
 
        for (unsigned int s = 0; s < 1 - r; s++)
13825
 
        {
13826
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
13827
 
          {
13828
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
13829
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
13830
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
13831
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
13832
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
13833
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
13834
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
13835
 
          }// end loop over 't'
13836
 
        }// end loop over 's'
13837
 
      }// end loop over 'r'
13838
 
      for (unsigned int r = 0; r < 3; r++)
13839
 
      {
13840
 
        for (unsigned int s = 0; s < 3 - r; s++)
13841
 
        {
13842
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
13843
 
          {
13844
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
13845
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
13846
 
          }// end loop over 't'
13847
 
        }// end loop over 's'
13848
 
      }// end loop over 'r'
 
10081
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
10082
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
10083
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
10084
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
10085
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
10086
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
10087
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
10088
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
10089
      basisvalues[0] *= std::sqrt(0.75);
 
10090
      basisvalues[3] *= std::sqrt(1.25);
 
10091
      basisvalues[9] *= std::sqrt(1.75);
 
10092
      basisvalues[2] *= std::sqrt(2.5);
 
10093
      basisvalues[8] *= std::sqrt(3.5);
 
10094
      basisvalues[7] *= std::sqrt(5.25);
 
10095
      basisvalues[1] *= std::sqrt(7.5);
 
10096
      basisvalues[6] *= std::sqrt(10.5);
 
10097
      basisvalues[5] *= std::sqrt(15.75);
 
10098
      basisvalues[4] *= std::sqrt(26.25);
13849
10099
      
13850
10100
      // Table(s) of coefficients.
13851
10101
      static const double coefficients0[10] = \
14037
10287
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
14038
10288
      
14039
10289
      // Declare helper variables.
14040
 
      unsigned int rr = 0;
14041
 
      unsigned int ss = 0;
14042
 
      unsigned int tt = 0;
14043
 
      double tmp5 = 0.0;
14044
 
      double tmp6 = 0.0;
14045
 
      double tmp7 = 0.0;
14046
10290
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
14047
10291
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
14048
10292
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
14052
10296
      // Compute basisvalues.
14053
10297
      basisvalues[0] = 1.0;
14054
10298
      basisvalues[1] = tmp0;
14055
 
      for (unsigned int r = 1; r < 2; r++)
14056
 
      {
14057
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
14058
 
        ss = r*(r + 1)*(r + 2)/6;
14059
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
14060
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
14061
 
      }// end loop over 'r'
14062
 
      for (unsigned int r = 0; r < 2; r++)
14063
 
      {
14064
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
14065
 
        ss = r*(r + 1)*(r + 2)/6;
14066
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
14067
 
      }// end loop over 'r'
14068
 
      for (unsigned int r = 0; r < 1; r++)
14069
 
      {
14070
 
        for (unsigned int s = 1; s < 2 - r; s++)
14071
 
        {
14072
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
14073
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
14074
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
14075
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
14076
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
14077
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
14078
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
14079
 
        }// end loop over 's'
14080
 
      }// end loop over 'r'
14081
 
      for (unsigned int r = 0; r < 2; r++)
14082
 
      {
14083
 
        for (unsigned int s = 0; s < 2 - r; s++)
14084
 
        {
14085
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
14086
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
14087
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
14088
 
        }// end loop over 's'
14089
 
      }// end loop over 'r'
14090
 
      for (unsigned int r = 0; r < 1; r++)
14091
 
      {
14092
 
        for (unsigned int s = 0; s < 1 - r; s++)
14093
 
        {
14094
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
14095
 
          {
14096
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
14097
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
14098
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
14099
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
14100
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
14101
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
14102
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
14103
 
          }// end loop over 't'
14104
 
        }// end loop over 's'
14105
 
      }// end loop over 'r'
14106
 
      for (unsigned int r = 0; r < 3; r++)
14107
 
      {
14108
 
        for (unsigned int s = 0; s < 3 - r; s++)
14109
 
        {
14110
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
14111
 
          {
14112
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
14113
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
14114
 
          }// end loop over 't'
14115
 
        }// end loop over 's'
14116
 
      }// end loop over 'r'
 
10299
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
10300
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
10301
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
10302
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
10303
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
10304
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
10305
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
10306
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
10307
      basisvalues[0] *= std::sqrt(0.75);
 
10308
      basisvalues[3] *= std::sqrt(1.25);
 
10309
      basisvalues[9] *= std::sqrt(1.75);
 
10310
      basisvalues[2] *= std::sqrt(2.5);
 
10311
      basisvalues[8] *= std::sqrt(3.5);
 
10312
      basisvalues[7] *= std::sqrt(5.25);
 
10313
      basisvalues[1] *= std::sqrt(7.5);
 
10314
      basisvalues[6] *= std::sqrt(10.5);
 
10315
      basisvalues[5] *= std::sqrt(15.75);
 
10316
      basisvalues[4] *= std::sqrt(26.25);
14117
10317
      
14118
10318
      // Table(s) of coefficients.
14119
10319
      static const double coefficients0[10] = \
14305
10505
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
14306
10506
      
14307
10507
      // Declare helper variables.
14308
 
      unsigned int rr = 0;
14309
 
      unsigned int ss = 0;
14310
 
      unsigned int tt = 0;
14311
 
      double tmp5 = 0.0;
14312
 
      double tmp6 = 0.0;
14313
 
      double tmp7 = 0.0;
14314
10508
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
14315
10509
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
14316
10510
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
14320
10514
      // Compute basisvalues.
14321
10515
      basisvalues[0] = 1.0;
14322
10516
      basisvalues[1] = tmp0;
14323
 
      for (unsigned int r = 1; r < 2; r++)
14324
 
      {
14325
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
14326
 
        ss = r*(r + 1)*(r + 2)/6;
14327
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
14328
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
14329
 
      }// end loop over 'r'
14330
 
      for (unsigned int r = 0; r < 2; r++)
14331
 
      {
14332
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
14333
 
        ss = r*(r + 1)*(r + 2)/6;
14334
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
14335
 
      }// end loop over 'r'
14336
 
      for (unsigned int r = 0; r < 1; r++)
14337
 
      {
14338
 
        for (unsigned int s = 1; s < 2 - r; s++)
14339
 
        {
14340
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
14341
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
14342
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
14343
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
14344
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
14345
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
14346
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
14347
 
        }// end loop over 's'
14348
 
      }// end loop over 'r'
14349
 
      for (unsigned int r = 0; r < 2; r++)
14350
 
      {
14351
 
        for (unsigned int s = 0; s < 2 - r; s++)
14352
 
        {
14353
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
14354
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
14355
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
14356
 
        }// end loop over 's'
14357
 
      }// end loop over 'r'
14358
 
      for (unsigned int r = 0; r < 1; r++)
14359
 
      {
14360
 
        for (unsigned int s = 0; s < 1 - r; s++)
14361
 
        {
14362
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
14363
 
          {
14364
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
14365
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
14366
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
14367
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
14368
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
14369
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
14370
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
14371
 
          }// end loop over 't'
14372
 
        }// end loop over 's'
14373
 
      }// end loop over 'r'
14374
 
      for (unsigned int r = 0; r < 3; r++)
14375
 
      {
14376
 
        for (unsigned int s = 0; s < 3 - r; s++)
14377
 
        {
14378
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
14379
 
          {
14380
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
14381
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
14382
 
          }// end loop over 't'
14383
 
        }// end loop over 's'
14384
 
      }// end loop over 'r'
 
10517
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
10518
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
10519
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
10520
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
10521
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
10522
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
10523
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
10524
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
10525
      basisvalues[0] *= std::sqrt(0.75);
 
10526
      basisvalues[3] *= std::sqrt(1.25);
 
10527
      basisvalues[9] *= std::sqrt(1.75);
 
10528
      basisvalues[2] *= std::sqrt(2.5);
 
10529
      basisvalues[8] *= std::sqrt(3.5);
 
10530
      basisvalues[7] *= std::sqrt(5.25);
 
10531
      basisvalues[1] *= std::sqrt(7.5);
 
10532
      basisvalues[6] *= std::sqrt(10.5);
 
10533
      basisvalues[5] *= std::sqrt(15.75);
 
10534
      basisvalues[4] *= std::sqrt(26.25);
14385
10535
      
14386
10536
      // Table(s) of coefficients.
14387
10537
      static const double coefficients0[10] = \
14573
10723
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
14574
10724
      
14575
10725
      // Declare helper variables.
14576
 
      unsigned int rr = 0;
14577
 
      unsigned int ss = 0;
14578
 
      unsigned int tt = 0;
14579
 
      double tmp5 = 0.0;
14580
 
      double tmp6 = 0.0;
14581
 
      double tmp7 = 0.0;
14582
10726
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
14583
10727
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
14584
10728
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
14588
10732
      // Compute basisvalues.
14589
10733
      basisvalues[0] = 1.0;
14590
10734
      basisvalues[1] = tmp0;
14591
 
      for (unsigned int r = 1; r < 2; r++)
14592
 
      {
14593
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
14594
 
        ss = r*(r + 1)*(r + 2)/6;
14595
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
14596
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
14597
 
      }// end loop over 'r'
14598
 
      for (unsigned int r = 0; r < 2; r++)
14599
 
      {
14600
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
14601
 
        ss = r*(r + 1)*(r + 2)/6;
14602
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
14603
 
      }// end loop over 'r'
14604
 
      for (unsigned int r = 0; r < 1; r++)
14605
 
      {
14606
 
        for (unsigned int s = 1; s < 2 - r; s++)
14607
 
        {
14608
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
14609
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
14610
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
14611
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
14612
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
14613
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
14614
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
14615
 
        }// end loop over 's'
14616
 
      }// end loop over 'r'
14617
 
      for (unsigned int r = 0; r < 2; r++)
14618
 
      {
14619
 
        for (unsigned int s = 0; s < 2 - r; s++)
14620
 
        {
14621
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
14622
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
14623
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
14624
 
        }// end loop over 's'
14625
 
      }// end loop over 'r'
14626
 
      for (unsigned int r = 0; r < 1; r++)
14627
 
      {
14628
 
        for (unsigned int s = 0; s < 1 - r; s++)
14629
 
        {
14630
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
14631
 
          {
14632
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
14633
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
14634
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
14635
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
14636
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
14637
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
14638
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
14639
 
          }// end loop over 't'
14640
 
        }// end loop over 's'
14641
 
      }// end loop over 'r'
14642
 
      for (unsigned int r = 0; r < 3; r++)
14643
 
      {
14644
 
        for (unsigned int s = 0; s < 3 - r; s++)
14645
 
        {
14646
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
14647
 
          {
14648
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
14649
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
14650
 
          }// end loop over 't'
14651
 
        }// end loop over 's'
14652
 
      }// end loop over 'r'
 
10735
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
10736
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
10737
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
10738
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
10739
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
10740
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
10741
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
10742
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
10743
      basisvalues[0] *= std::sqrt(0.75);
 
10744
      basisvalues[3] *= std::sqrt(1.25);
 
10745
      basisvalues[9] *= std::sqrt(1.75);
 
10746
      basisvalues[2] *= std::sqrt(2.5);
 
10747
      basisvalues[8] *= std::sqrt(3.5);
 
10748
      basisvalues[7] *= std::sqrt(5.25);
 
10749
      basisvalues[1] *= std::sqrt(7.5);
 
10750
      basisvalues[6] *= std::sqrt(10.5);
 
10751
      basisvalues[5] *= std::sqrt(15.75);
 
10752
      basisvalues[4] *= std::sqrt(26.25);
14653
10753
      
14654
10754
      // Table(s) of coefficients.
14655
10755
      static const double coefficients0[10] = \
14841
10941
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
14842
10942
      
14843
10943
      // Declare helper variables.
14844
 
      unsigned int rr = 0;
14845
 
      unsigned int ss = 0;
14846
 
      unsigned int tt = 0;
14847
 
      double tmp5 = 0.0;
14848
 
      double tmp6 = 0.0;
14849
 
      double tmp7 = 0.0;
14850
10944
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
14851
10945
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
14852
10946
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
14856
10950
      // Compute basisvalues.
14857
10951
      basisvalues[0] = 1.0;
14858
10952
      basisvalues[1] = tmp0;
14859
 
      for (unsigned int r = 1; r < 2; r++)
14860
 
      {
14861
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
14862
 
        ss = r*(r + 1)*(r + 2)/6;
14863
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
14864
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
14865
 
      }// end loop over 'r'
14866
 
      for (unsigned int r = 0; r < 2; r++)
14867
 
      {
14868
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
14869
 
        ss = r*(r + 1)*(r + 2)/6;
14870
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
14871
 
      }// end loop over 'r'
14872
 
      for (unsigned int r = 0; r < 1; r++)
14873
 
      {
14874
 
        for (unsigned int s = 1; s < 2 - r; s++)
14875
 
        {
14876
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
14877
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
14878
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
14879
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
14880
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
14881
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
14882
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
14883
 
        }// end loop over 's'
14884
 
      }// end loop over 'r'
14885
 
      for (unsigned int r = 0; r < 2; r++)
14886
 
      {
14887
 
        for (unsigned int s = 0; s < 2 - r; s++)
14888
 
        {
14889
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
14890
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
14891
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
14892
 
        }// end loop over 's'
14893
 
      }// end loop over 'r'
14894
 
      for (unsigned int r = 0; r < 1; r++)
14895
 
      {
14896
 
        for (unsigned int s = 0; s < 1 - r; s++)
14897
 
        {
14898
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
14899
 
          {
14900
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
14901
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
14902
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
14903
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
14904
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
14905
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
14906
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
14907
 
          }// end loop over 't'
14908
 
        }// end loop over 's'
14909
 
      }// end loop over 'r'
14910
 
      for (unsigned int r = 0; r < 3; r++)
14911
 
      {
14912
 
        for (unsigned int s = 0; s < 3 - r; s++)
14913
 
        {
14914
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
14915
 
          {
14916
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
14917
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
14918
 
          }// end loop over 't'
14919
 
        }// end loop over 's'
14920
 
      }// end loop over 'r'
 
10953
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
10954
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
10955
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
10956
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
10957
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
10958
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
10959
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
10960
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
10961
      basisvalues[0] *= std::sqrt(0.75);
 
10962
      basisvalues[3] *= std::sqrt(1.25);
 
10963
      basisvalues[9] *= std::sqrt(1.75);
 
10964
      basisvalues[2] *= std::sqrt(2.5);
 
10965
      basisvalues[8] *= std::sqrt(3.5);
 
10966
      basisvalues[7] *= std::sqrt(5.25);
 
10967
      basisvalues[1] *= std::sqrt(7.5);
 
10968
      basisvalues[6] *= std::sqrt(10.5);
 
10969
      basisvalues[5] *= std::sqrt(15.75);
 
10970
      basisvalues[4] *= std::sqrt(26.25);
14921
10971
      
14922
10972
      // Table(s) of coefficients.
14923
10973
      static const double coefficients0[10] = \
15109
11159
      double basisvalues[10] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
15110
11160
      
15111
11161
      // Declare helper variables.
15112
 
      unsigned int rr = 0;
15113
 
      unsigned int ss = 0;
15114
 
      unsigned int tt = 0;
15115
 
      double tmp5 = 0.0;
15116
 
      double tmp6 = 0.0;
15117
 
      double tmp7 = 0.0;
15118
11162
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
15119
11163
      double tmp1 = 0.25*(Y + Z)*(Y + Z);
15120
11164
      double tmp2 = 0.5*(1.0 + Z + 2.0*Y);
15124
11168
      // Compute basisvalues.
15125
11169
      basisvalues[0] = 1.0;
15126
11170
      basisvalues[1] = tmp0;
15127
 
      for (unsigned int r = 1; r < 2; r++)
15128
 
      {
15129
 
        rr = (r + 1)*((r + 1) + 1)*((r + 1) + 2)/6;
15130
 
        ss = r*(r + 1)*(r + 2)/6;
15131
 
        tt = (r - 1)*((r - 1) + 1)*((r - 1) + 2)/6;
15132
 
        basisvalues[rr] = (basisvalues[ss]*tmp0*(1.0 + 2.0*r)/(1.0 + r) - basisvalues[tt]*tmp1*r/(1.0 + r));
15133
 
      }// end loop over 'r'
15134
 
      for (unsigned int r = 0; r < 2; r++)
15135
 
      {
15136
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
15137
 
        ss = r*(r + 1)*(r + 2)/6;
15138
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
15139
 
      }// end loop over 'r'
15140
 
      for (unsigned int r = 0; r < 1; r++)
15141
 
      {
15142
 
        for (unsigned int s = 1; s < 2 - r; s++)
15143
 
        {
15144
 
          rr = (r + (s + 1))*(r + (s + 1) + 1)*(r + (s + 1) + 2)/6 + (s + 1)*((s + 1) + 1)/2;
15145
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
15146
 
          tt = (r + (s - 1))*(r + (s - 1) + 1)*(r + (s - 1) + 2)/6 + (s - 1)*((s - 1) + 1)/2;
15147
 
          tmp5 = (2.0 + 2.0*r + 2.0*s)*(3.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + s)*(2.0 + s + 2.0*r));
15148
 
          tmp6 = (1.0 + 4.0*r*r + 4.0*r)*(2.0 + 2.0*r + 2.0*s)/(2.0*(1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
15149
 
          tmp7 = (1.0 + s + 2.0*r)*(3.0 + 2.0*r + 2.0*s)*s/((1.0 + 2.0*r + 2.0*s)*(1.0 + s)*(2.0 + s + 2.0*r));
15150
 
          basisvalues[rr] = (basisvalues[ss]*(tmp2*tmp5 + tmp3*tmp6) - basisvalues[tt]*tmp4*tmp7);
15151
 
        }// end loop over 's'
15152
 
      }// end loop over 'r'
15153
 
      for (unsigned int r = 0; r < 2; r++)
15154
 
      {
15155
 
        for (unsigned int s = 0; s < 2 - r; s++)
15156
 
        {
15157
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
15158
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
15159
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
15160
 
        }// end loop over 's'
15161
 
      }// end loop over 'r'
15162
 
      for (unsigned int r = 0; r < 1; r++)
15163
 
      {
15164
 
        for (unsigned int s = 0; s < 1 - r; s++)
15165
 
        {
15166
 
          for (unsigned int t = 1; t < 2 - r - s; t++)
15167
 
          {
15168
 
            rr = (r + s + t + 1)*(r + s + t + 1 + 1)*(r + s + t + 1 + 2)/6 + (s + t + 1)*(s + t + 1 + 1)/2 + t + 1;
15169
 
            ss = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
15170
 
            tt = (r + s + t - 1)*(r + s + t - 1 + 1)*(r + s + t - 1 + 2)/6 + (s + t - 1)*(s + t - 1 + 1)/2 + t - 1;
15171
 
            tmp5 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 2.0*r + 2.0*s + 2.0*t)/(2.0*(1.0 + t)*(3.0 + t + 2.0*r + 2.0*s));
15172
 
            tmp6 = (3.0 + 2.0*r + 2.0*s + 2.0*t)*(4.0 + 4.0*r*r + 4.0*s*s + 8.0*r*s + 8.0*r + 8.0*s)/(2.0*(1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
15173
 
            tmp7 = (2.0 + t + 2.0*r + 2.0*s)*(4.0 + 2.0*r + 2.0*s + 2.0*t)*t/((1.0 + t)*(2.0 + 2.0*r + 2.0*s + 2.0*t)*(3.0 + t + 2.0*r + 2.0*s));
15174
 
            basisvalues[rr] = (basisvalues[ss]*(tmp6 + Z*tmp5) - basisvalues[tt]*tmp7);
15175
 
          }// end loop over 't'
15176
 
        }// end loop over 's'
15177
 
      }// end loop over 'r'
15178
 
      for (unsigned int r = 0; r < 3; r++)
15179
 
      {
15180
 
        for (unsigned int s = 0; s < 3 - r; s++)
15181
 
        {
15182
 
          for (unsigned int t = 0; t < 3 - r - s; t++)
15183
 
          {
15184
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
15185
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
15186
 
          }// end loop over 't'
15187
 
        }// end loop over 's'
15188
 
      }// end loop over 'r'
 
11171
      basisvalues[4] = 1.5*tmp0*basisvalues[1] - 0.5*tmp1*basisvalues[0];
 
11172
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
11173
      basisvalues[5] = (0.5*(2.0 + 3.0*Y + Z) + 1.0*(1.0 + Y))*basisvalues[1];
 
11174
      basisvalues[7] = (1.6666667*tmp2 + 0.11111111*tmp3)*basisvalues[2] - 0.55555556*tmp4*basisvalues[0];
 
11175
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
11176
      basisvalues[8] = (3.0*Z + 2.0)*basisvalues[2];
 
11177
      basisvalues[6] = (3.0*Z + 2.0)*basisvalues[1];
 
11178
      basisvalues[9] = basisvalues[3]*(0.3125 + 1.875*Z) - 0.5625*basisvalues[0];
 
11179
      basisvalues[0] *= std::sqrt(0.75);
 
11180
      basisvalues[3] *= std::sqrt(1.25);
 
11181
      basisvalues[9] *= std::sqrt(1.75);
 
11182
      basisvalues[2] *= std::sqrt(2.5);
 
11183
      basisvalues[8] *= std::sqrt(3.5);
 
11184
      basisvalues[7] *= std::sqrt(5.25);
 
11185
      basisvalues[1] *= std::sqrt(7.5);
 
11186
      basisvalues[6] *= std::sqrt(10.5);
 
11187
      basisvalues[5] *= std::sqrt(15.75);
 
11188
      basisvalues[4] *= std::sqrt(26.25);
15189
11189
      
15190
11190
      // Table(s) of coefficients.
15191
11191
      static const double coefficients0[10] = \
16054
12054
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
16055
12055
      
16056
12056
      // Declare helper variables.
16057
 
      unsigned int rr = 0;
16058
 
      unsigned int ss = 0;
16059
12057
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
16060
12058
      
16061
12059
      // Compute basisvalues.
16062
12060
      basisvalues[0] = 1.0;
16063
12061
      basisvalues[1] = tmp0;
16064
 
      for (unsigned int r = 0; r < 1; r++)
16065
 
      {
16066
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
16067
 
        ss = r*(r + 1)*(r + 2)/6;
16068
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
16069
 
      }// end loop over 'r'
16070
 
      for (unsigned int r = 0; r < 1; r++)
16071
 
      {
16072
 
        for (unsigned int s = 0; s < 1 - r; s++)
16073
 
        {
16074
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
16075
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
16076
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
16077
 
        }// end loop over 's'
16078
 
      }// end loop over 'r'
16079
 
      for (unsigned int r = 0; r < 2; r++)
16080
 
      {
16081
 
        for (unsigned int s = 0; s < 2 - r; s++)
16082
 
        {
16083
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
16084
 
          {
16085
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
16086
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
16087
 
          }// end loop over 't'
16088
 
        }// end loop over 's'
16089
 
      }// end loop over 'r'
 
12062
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
12063
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
12064
      basisvalues[0] *= std::sqrt(0.75);
 
12065
      basisvalues[3] *= std::sqrt(1.25);
 
12066
      basisvalues[2] *= std::sqrt(2.5);
 
12067
      basisvalues[1] *= std::sqrt(7.5);
16090
12068
      
16091
12069
      // Table(s) of coefficients.
16092
12070
      static const double coefficients0[4] = \
16106
12084
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
16107
12085
      
16108
12086
      // Declare helper variables.
16109
 
      unsigned int rr = 0;
16110
 
      unsigned int ss = 0;
16111
12087
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
16112
12088
      
16113
12089
      // Compute basisvalues.
16114
12090
      basisvalues[0] = 1.0;
16115
12091
      basisvalues[1] = tmp0;
16116
 
      for (unsigned int r = 0; r < 1; r++)
16117
 
      {
16118
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
16119
 
        ss = r*(r + 1)*(r + 2)/6;
16120
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
16121
 
      }// end loop over 'r'
16122
 
      for (unsigned int r = 0; r < 1; r++)
16123
 
      {
16124
 
        for (unsigned int s = 0; s < 1 - r; s++)
16125
 
        {
16126
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
16127
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
16128
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
16129
 
        }// end loop over 's'
16130
 
      }// end loop over 'r'
16131
 
      for (unsigned int r = 0; r < 2; r++)
16132
 
      {
16133
 
        for (unsigned int s = 0; s < 2 - r; s++)
16134
 
        {
16135
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
16136
 
          {
16137
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
16138
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
16139
 
          }// end loop over 't'
16140
 
        }// end loop over 's'
16141
 
      }// end loop over 'r'
 
12092
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
12093
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
12094
      basisvalues[0] *= std::sqrt(0.75);
 
12095
      basisvalues[3] *= std::sqrt(1.25);
 
12096
      basisvalues[2] *= std::sqrt(2.5);
 
12097
      basisvalues[1] *= std::sqrt(7.5);
16142
12098
      
16143
12099
      // Table(s) of coefficients.
16144
12100
      static const double coefficients0[4] = \
16158
12114
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
16159
12115
      
16160
12116
      // Declare helper variables.
16161
 
      unsigned int rr = 0;
16162
 
      unsigned int ss = 0;
16163
12117
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
16164
12118
      
16165
12119
      // Compute basisvalues.
16166
12120
      basisvalues[0] = 1.0;
16167
12121
      basisvalues[1] = tmp0;
16168
 
      for (unsigned int r = 0; r < 1; r++)
16169
 
      {
16170
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
16171
 
        ss = r*(r + 1)*(r + 2)/6;
16172
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
16173
 
      }// end loop over 'r'
16174
 
      for (unsigned int r = 0; r < 1; r++)
16175
 
      {
16176
 
        for (unsigned int s = 0; s < 1 - r; s++)
16177
 
        {
16178
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
16179
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
16180
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
16181
 
        }// end loop over 's'
16182
 
      }// end loop over 'r'
16183
 
      for (unsigned int r = 0; r < 2; r++)
16184
 
      {
16185
 
        for (unsigned int s = 0; s < 2 - r; s++)
16186
 
        {
16187
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
16188
 
          {
16189
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
16190
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
16191
 
          }// end loop over 't'
16192
 
        }// end loop over 's'
16193
 
      }// end loop over 'r'
 
12122
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
12123
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
12124
      basisvalues[0] *= std::sqrt(0.75);
 
12125
      basisvalues[3] *= std::sqrt(1.25);
 
12126
      basisvalues[2] *= std::sqrt(2.5);
 
12127
      basisvalues[1] *= std::sqrt(7.5);
16194
12128
      
16195
12129
      // Table(s) of coefficients.
16196
12130
      static const double coefficients0[4] = \
16210
12144
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
16211
12145
      
16212
12146
      // Declare helper variables.
16213
 
      unsigned int rr = 0;
16214
 
      unsigned int ss = 0;
16215
12147
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
16216
12148
      
16217
12149
      // Compute basisvalues.
16218
12150
      basisvalues[0] = 1.0;
16219
12151
      basisvalues[1] = tmp0;
16220
 
      for (unsigned int r = 0; r < 1; r++)
16221
 
      {
16222
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
16223
 
        ss = r*(r + 1)*(r + 2)/6;
16224
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
16225
 
      }// end loop over 'r'
16226
 
      for (unsigned int r = 0; r < 1; r++)
16227
 
      {
16228
 
        for (unsigned int s = 0; s < 1 - r; s++)
16229
 
        {
16230
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
16231
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
16232
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
16233
 
        }// end loop over 's'
16234
 
      }// end loop over 'r'
16235
 
      for (unsigned int r = 0; r < 2; r++)
16236
 
      {
16237
 
        for (unsigned int s = 0; s < 2 - r; s++)
16238
 
        {
16239
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
16240
 
          {
16241
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
16242
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
16243
 
          }// end loop over 't'
16244
 
        }// end loop over 's'
16245
 
      }// end loop over 'r'
 
12152
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
12153
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
12154
      basisvalues[0] *= std::sqrt(0.75);
 
12155
      basisvalues[3] *= std::sqrt(1.25);
 
12156
      basisvalues[2] *= std::sqrt(2.5);
 
12157
      basisvalues[1] *= std::sqrt(7.5);
16246
12158
      
16247
12159
      // Table(s) of coefficients.
16248
12160
      static const double coefficients0[4] = \
16405
12317
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
16406
12318
      
16407
12319
      // Declare helper variables.
16408
 
      unsigned int rr = 0;
16409
 
      unsigned int ss = 0;
16410
12320
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
16411
12321
      
16412
12322
      // Compute basisvalues.
16413
12323
      basisvalues[0] = 1.0;
16414
12324
      basisvalues[1] = tmp0;
16415
 
      for (unsigned int r = 0; r < 1; r++)
16416
 
      {
16417
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
16418
 
        ss = r*(r + 1)*(r + 2)/6;
16419
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
16420
 
      }// end loop over 'r'
16421
 
      for (unsigned int r = 0; r < 1; r++)
16422
 
      {
16423
 
        for (unsigned int s = 0; s < 1 - r; s++)
16424
 
        {
16425
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
16426
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
16427
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
16428
 
        }// end loop over 's'
16429
 
      }// end loop over 'r'
16430
 
      for (unsigned int r = 0; r < 2; r++)
16431
 
      {
16432
 
        for (unsigned int s = 0; s < 2 - r; s++)
16433
 
        {
16434
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
16435
 
          {
16436
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
16437
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
16438
 
          }// end loop over 't'
16439
 
        }// end loop over 's'
16440
 
      }// end loop over 'r'
 
12325
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
12326
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
12327
      basisvalues[0] *= std::sqrt(0.75);
 
12328
      basisvalues[3] *= std::sqrt(1.25);
 
12329
      basisvalues[2] *= std::sqrt(2.5);
 
12330
      basisvalues[1] *= std::sqrt(7.5);
16441
12331
      
16442
12332
      // Table(s) of coefficients.
16443
12333
      static const double coefficients0[4] = \
16599
12489
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
16600
12490
      
16601
12491
      // Declare helper variables.
16602
 
      unsigned int rr = 0;
16603
 
      unsigned int ss = 0;
16604
12492
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
16605
12493
      
16606
12494
      // Compute basisvalues.
16607
12495
      basisvalues[0] = 1.0;
16608
12496
      basisvalues[1] = tmp0;
16609
 
      for (unsigned int r = 0; r < 1; r++)
16610
 
      {
16611
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
16612
 
        ss = r*(r + 1)*(r + 2)/6;
16613
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
16614
 
      }// end loop over 'r'
16615
 
      for (unsigned int r = 0; r < 1; r++)
16616
 
      {
16617
 
        for (unsigned int s = 0; s < 1 - r; s++)
16618
 
        {
16619
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
16620
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
16621
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
16622
 
        }// end loop over 's'
16623
 
      }// end loop over 'r'
16624
 
      for (unsigned int r = 0; r < 2; r++)
16625
 
      {
16626
 
        for (unsigned int s = 0; s < 2 - r; s++)
16627
 
        {
16628
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
16629
 
          {
16630
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
16631
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
16632
 
          }// end loop over 't'
16633
 
        }// end loop over 's'
16634
 
      }// end loop over 'r'
 
12497
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
12498
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
12499
      basisvalues[0] *= std::sqrt(0.75);
 
12500
      basisvalues[3] *= std::sqrt(1.25);
 
12501
      basisvalues[2] *= std::sqrt(2.5);
 
12502
      basisvalues[1] *= std::sqrt(7.5);
16635
12503
      
16636
12504
      // Table(s) of coefficients.
16637
12505
      static const double coefficients0[4] = \
16793
12661
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
16794
12662
      
16795
12663
      // Declare helper variables.
16796
 
      unsigned int rr = 0;
16797
 
      unsigned int ss = 0;
16798
12664
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
16799
12665
      
16800
12666
      // Compute basisvalues.
16801
12667
      basisvalues[0] = 1.0;
16802
12668
      basisvalues[1] = tmp0;
16803
 
      for (unsigned int r = 0; r < 1; r++)
16804
 
      {
16805
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
16806
 
        ss = r*(r + 1)*(r + 2)/6;
16807
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
16808
 
      }// end loop over 'r'
16809
 
      for (unsigned int r = 0; r < 1; r++)
16810
 
      {
16811
 
        for (unsigned int s = 0; s < 1 - r; s++)
16812
 
        {
16813
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
16814
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
16815
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
16816
 
        }// end loop over 's'
16817
 
      }// end loop over 'r'
16818
 
      for (unsigned int r = 0; r < 2; r++)
16819
 
      {
16820
 
        for (unsigned int s = 0; s < 2 - r; s++)
16821
 
        {
16822
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
16823
 
          {
16824
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
16825
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
16826
 
          }// end loop over 't'
16827
 
        }// end loop over 's'
16828
 
      }// end loop over 'r'
 
12669
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
12670
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
12671
      basisvalues[0] *= std::sqrt(0.75);
 
12672
      basisvalues[3] *= std::sqrt(1.25);
 
12673
      basisvalues[2] *= std::sqrt(2.5);
 
12674
      basisvalues[1] *= std::sqrt(7.5);
16829
12675
      
16830
12676
      // Table(s) of coefficients.
16831
12677
      static const double coefficients0[4] = \
16987
12833
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
16988
12834
      
16989
12835
      // Declare helper variables.
16990
 
      unsigned int rr = 0;
16991
 
      unsigned int ss = 0;
16992
12836
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
16993
12837
      
16994
12838
      // Compute basisvalues.
16995
12839
      basisvalues[0] = 1.0;
16996
12840
      basisvalues[1] = tmp0;
16997
 
      for (unsigned int r = 0; r < 1; r++)
16998
 
      {
16999
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
17000
 
        ss = r*(r + 1)*(r + 2)/6;
17001
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
17002
 
      }// end loop over 'r'
17003
 
      for (unsigned int r = 0; r < 1; r++)
17004
 
      {
17005
 
        for (unsigned int s = 0; s < 1 - r; s++)
17006
 
        {
17007
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
17008
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
17009
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
17010
 
        }// end loop over 's'
17011
 
      }// end loop over 'r'
17012
 
      for (unsigned int r = 0; r < 2; r++)
17013
 
      {
17014
 
        for (unsigned int s = 0; s < 2 - r; s++)
17015
 
        {
17016
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
17017
 
          {
17018
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
17019
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
17020
 
          }// end loop over 't'
17021
 
        }// end loop over 's'
17022
 
      }// end loop over 'r'
 
12841
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
12842
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
12843
      basisvalues[0] *= std::sqrt(0.75);
 
12844
      basisvalues[3] *= std::sqrt(1.25);
 
12845
      basisvalues[2] *= std::sqrt(2.5);
 
12846
      basisvalues[1] *= std::sqrt(7.5);
17023
12847
      
17024
12848
      // Table(s) of coefficients.
17025
12849
      static const double coefficients0[4] = \
17485
13309
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
17486
13310
      
17487
13311
      // Declare helper variables.
17488
 
      unsigned int rr = 0;
17489
 
      unsigned int ss = 0;
17490
13312
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
17491
13313
      
17492
13314
      // Compute basisvalues.
17493
13315
      basisvalues[0] = 1.0;
17494
13316
      basisvalues[1] = tmp0;
17495
 
      for (unsigned int r = 0; r < 1; r++)
17496
 
      {
17497
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
17498
 
        ss = r*(r + 1)*(r + 2)/6;
17499
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
17500
 
      }// end loop over 'r'
17501
 
      for (unsigned int r = 0; r < 1; r++)
17502
 
      {
17503
 
        for (unsigned int s = 0; s < 1 - r; s++)
17504
 
        {
17505
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
17506
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
17507
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
17508
 
        }// end loop over 's'
17509
 
      }// end loop over 'r'
17510
 
      for (unsigned int r = 0; r < 2; r++)
17511
 
      {
17512
 
        for (unsigned int s = 0; s < 2 - r; s++)
17513
 
        {
17514
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
17515
 
          {
17516
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
17517
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
17518
 
          }// end loop over 't'
17519
 
        }// end loop over 's'
17520
 
      }// end loop over 'r'
 
13317
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
13318
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
13319
      basisvalues[0] *= std::sqrt(0.75);
 
13320
      basisvalues[3] *= std::sqrt(1.25);
 
13321
      basisvalues[2] *= std::sqrt(2.5);
 
13322
      basisvalues[1] *= std::sqrt(7.5);
17521
13323
      
17522
13324
      // Table(s) of coefficients.
17523
13325
      static const double coefficients0[4] = \
17553
13355
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
17554
13356
      
17555
13357
      // Declare helper variables.
17556
 
      unsigned int rr = 0;
17557
 
      unsigned int ss = 0;
17558
13358
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
17559
13359
      
17560
13360
      // Compute basisvalues.
17561
13361
      basisvalues[0] = 1.0;
17562
13362
      basisvalues[1] = tmp0;
17563
 
      for (unsigned int r = 0; r < 1; r++)
17564
 
      {
17565
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
17566
 
        ss = r*(r + 1)*(r + 2)/6;
17567
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
17568
 
      }// end loop over 'r'
17569
 
      for (unsigned int r = 0; r < 1; r++)
17570
 
      {
17571
 
        for (unsigned int s = 0; s < 1 - r; s++)
17572
 
        {
17573
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
17574
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
17575
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
17576
 
        }// end loop over 's'
17577
 
      }// end loop over 'r'
17578
 
      for (unsigned int r = 0; r < 2; r++)
17579
 
      {
17580
 
        for (unsigned int s = 0; s < 2 - r; s++)
17581
 
        {
17582
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
17583
 
          {
17584
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
17585
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
17586
 
          }// end loop over 't'
17587
 
        }// end loop over 's'
17588
 
      }// end loop over 'r'
 
13363
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
13364
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
13365
      basisvalues[0] *= std::sqrt(0.75);
 
13366
      basisvalues[3] *= std::sqrt(1.25);
 
13367
      basisvalues[2] *= std::sqrt(2.5);
 
13368
      basisvalues[1] *= std::sqrt(7.5);
17589
13369
      
17590
13370
      // Table(s) of coefficients.
17591
13371
      static const double coefficients0[4] = \
17621
13401
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
17622
13402
      
17623
13403
      // Declare helper variables.
17624
 
      unsigned int rr = 0;
17625
 
      unsigned int ss = 0;
17626
13404
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
17627
13405
      
17628
13406
      // Compute basisvalues.
17629
13407
      basisvalues[0] = 1.0;
17630
13408
      basisvalues[1] = tmp0;
17631
 
      for (unsigned int r = 0; r < 1; r++)
17632
 
      {
17633
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
17634
 
        ss = r*(r + 1)*(r + 2)/6;
17635
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
17636
 
      }// end loop over 'r'
17637
 
      for (unsigned int r = 0; r < 1; r++)
17638
 
      {
17639
 
        for (unsigned int s = 0; s < 1 - r; s++)
17640
 
        {
17641
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
17642
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
17643
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
17644
 
        }// end loop over 's'
17645
 
      }// end loop over 'r'
17646
 
      for (unsigned int r = 0; r < 2; r++)
17647
 
      {
17648
 
        for (unsigned int s = 0; s < 2 - r; s++)
17649
 
        {
17650
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
17651
 
          {
17652
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
17653
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
17654
 
          }// end loop over 't'
17655
 
        }// end loop over 's'
17656
 
      }// end loop over 'r'
 
13409
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
13410
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
13411
      basisvalues[0] *= std::sqrt(0.75);
 
13412
      basisvalues[3] *= std::sqrt(1.25);
 
13413
      basisvalues[2] *= std::sqrt(2.5);
 
13414
      basisvalues[1] *= std::sqrt(7.5);
17657
13415
      
17658
13416
      // Table(s) of coefficients.
17659
13417
      static const double coefficients0[4] = \
17689
13447
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
17690
13448
      
17691
13449
      // Declare helper variables.
17692
 
      unsigned int rr = 0;
17693
 
      unsigned int ss = 0;
17694
13450
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
17695
13451
      
17696
13452
      // Compute basisvalues.
17697
13453
      basisvalues[0] = 1.0;
17698
13454
      basisvalues[1] = tmp0;
17699
 
      for (unsigned int r = 0; r < 1; r++)
17700
 
      {
17701
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
17702
 
        ss = r*(r + 1)*(r + 2)/6;
17703
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
17704
 
      }// end loop over 'r'
17705
 
      for (unsigned int r = 0; r < 1; r++)
17706
 
      {
17707
 
        for (unsigned int s = 0; s < 1 - r; s++)
17708
 
        {
17709
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
17710
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
17711
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
17712
 
        }// end loop over 's'
17713
 
      }// end loop over 'r'
17714
 
      for (unsigned int r = 0; r < 2; r++)
17715
 
      {
17716
 
        for (unsigned int s = 0; s < 2 - r; s++)
17717
 
        {
17718
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
17719
 
          {
17720
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
17721
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
17722
 
          }// end loop over 't'
17723
 
        }// end loop over 's'
17724
 
      }// end loop over 'r'
 
13455
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
13456
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
13457
      basisvalues[0] *= std::sqrt(0.75);
 
13458
      basisvalues[3] *= std::sqrt(1.25);
 
13459
      basisvalues[2] *= std::sqrt(2.5);
 
13460
      basisvalues[1] *= std::sqrt(7.5);
17725
13461
      
17726
13462
      // Table(s) of coefficients.
17727
13463
      static const double coefficients0[4] = \
17757
13493
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
17758
13494
      
17759
13495
      // Declare helper variables.
17760
 
      unsigned int rr = 0;
17761
 
      unsigned int ss = 0;
17762
13496
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
17763
13497
      
17764
13498
      // Compute basisvalues.
17765
13499
      basisvalues[0] = 1.0;
17766
13500
      basisvalues[1] = tmp0;
17767
 
      for (unsigned int r = 0; r < 1; r++)
17768
 
      {
17769
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
17770
 
        ss = r*(r + 1)*(r + 2)/6;
17771
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
17772
 
      }// end loop over 'r'
17773
 
      for (unsigned int r = 0; r < 1; r++)
17774
 
      {
17775
 
        for (unsigned int s = 0; s < 1 - r; s++)
17776
 
        {
17777
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
17778
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
17779
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
17780
 
        }// end loop over 's'
17781
 
      }// end loop over 'r'
17782
 
      for (unsigned int r = 0; r < 2; r++)
17783
 
      {
17784
 
        for (unsigned int s = 0; s < 2 - r; s++)
17785
 
        {
17786
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
17787
 
          {
17788
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
17789
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
17790
 
          }// end loop over 't'
17791
 
        }// end loop over 's'
17792
 
      }// end loop over 'r'
 
13501
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
13502
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
13503
      basisvalues[0] *= std::sqrt(0.75);
 
13504
      basisvalues[3] *= std::sqrt(1.25);
 
13505
      basisvalues[2] *= std::sqrt(2.5);
 
13506
      basisvalues[1] *= std::sqrt(7.5);
17793
13507
      
17794
13508
      // Table(s) of coefficients.
17795
13509
      static const double coefficients0[4] = \
17825
13539
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
17826
13540
      
17827
13541
      // Declare helper variables.
17828
 
      unsigned int rr = 0;
17829
 
      unsigned int ss = 0;
17830
13542
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
17831
13543
      
17832
13544
      // Compute basisvalues.
17833
13545
      basisvalues[0] = 1.0;
17834
13546
      basisvalues[1] = tmp0;
17835
 
      for (unsigned int r = 0; r < 1; r++)
17836
 
      {
17837
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
17838
 
        ss = r*(r + 1)*(r + 2)/6;
17839
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
17840
 
      }// end loop over 'r'
17841
 
      for (unsigned int r = 0; r < 1; r++)
17842
 
      {
17843
 
        for (unsigned int s = 0; s < 1 - r; s++)
17844
 
        {
17845
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
17846
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
17847
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
17848
 
        }// end loop over 's'
17849
 
      }// end loop over 'r'
17850
 
      for (unsigned int r = 0; r < 2; r++)
17851
 
      {
17852
 
        for (unsigned int s = 0; s < 2 - r; s++)
17853
 
        {
17854
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
17855
 
          {
17856
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
17857
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
17858
 
          }// end loop over 't'
17859
 
        }// end loop over 's'
17860
 
      }// end loop over 'r'
 
13547
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
13548
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
13549
      basisvalues[0] *= std::sqrt(0.75);
 
13550
      basisvalues[3] *= std::sqrt(1.25);
 
13551
      basisvalues[2] *= std::sqrt(2.5);
 
13552
      basisvalues[1] *= std::sqrt(7.5);
17861
13553
      
17862
13554
      // Table(s) of coefficients.
17863
13555
      static const double coefficients0[4] = \
18039
13731
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
18040
13732
      
18041
13733
      // Declare helper variables.
18042
 
      unsigned int rr = 0;
18043
 
      unsigned int ss = 0;
18044
13734
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
18045
13735
      
18046
13736
      // Compute basisvalues.
18047
13737
      basisvalues[0] = 1.0;
18048
13738
      basisvalues[1] = tmp0;
18049
 
      for (unsigned int r = 0; r < 1; r++)
18050
 
      {
18051
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
18052
 
        ss = r*(r + 1)*(r + 2)/6;
18053
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
18054
 
      }// end loop over 'r'
18055
 
      for (unsigned int r = 0; r < 1; r++)
18056
 
      {
18057
 
        for (unsigned int s = 0; s < 1 - r; s++)
18058
 
        {
18059
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
18060
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
18061
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
18062
 
        }// end loop over 's'
18063
 
      }// end loop over 'r'
18064
 
      for (unsigned int r = 0; r < 2; r++)
18065
 
      {
18066
 
        for (unsigned int s = 0; s < 2 - r; s++)
18067
 
        {
18068
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
18069
 
          {
18070
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
18071
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
18072
 
          }// end loop over 't'
18073
 
        }// end loop over 's'
18074
 
      }// end loop over 'r'
 
13739
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
13740
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
13741
      basisvalues[0] *= std::sqrt(0.75);
 
13742
      basisvalues[3] *= std::sqrt(1.25);
 
13743
      basisvalues[2] *= std::sqrt(2.5);
 
13744
      basisvalues[1] *= std::sqrt(7.5);
18075
13745
      
18076
13746
      // Table(s) of coefficients.
18077
13747
      static const double coefficients0[4] = \
18251
13921
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
18252
13922
      
18253
13923
      // Declare helper variables.
18254
 
      unsigned int rr = 0;
18255
 
      unsigned int ss = 0;
18256
13924
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
18257
13925
      
18258
13926
      // Compute basisvalues.
18259
13927
      basisvalues[0] = 1.0;
18260
13928
      basisvalues[1] = tmp0;
18261
 
      for (unsigned int r = 0; r < 1; r++)
18262
 
      {
18263
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
18264
 
        ss = r*(r + 1)*(r + 2)/6;
18265
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
18266
 
      }// end loop over 'r'
18267
 
      for (unsigned int r = 0; r < 1; r++)
18268
 
      {
18269
 
        for (unsigned int s = 0; s < 1 - r; s++)
18270
 
        {
18271
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
18272
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
18273
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
18274
 
        }// end loop over 's'
18275
 
      }// end loop over 'r'
18276
 
      for (unsigned int r = 0; r < 2; r++)
18277
 
      {
18278
 
        for (unsigned int s = 0; s < 2 - r; s++)
18279
 
        {
18280
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
18281
 
          {
18282
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
18283
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
18284
 
          }// end loop over 't'
18285
 
        }// end loop over 's'
18286
 
      }// end loop over 'r'
 
13929
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
13930
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
13931
      basisvalues[0] *= std::sqrt(0.75);
 
13932
      basisvalues[3] *= std::sqrt(1.25);
 
13933
      basisvalues[2] *= std::sqrt(2.5);
 
13934
      basisvalues[1] *= std::sqrt(7.5);
18287
13935
      
18288
13936
      // Table(s) of coefficients.
18289
13937
      static const double coefficients0[4] = \
18463
14111
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
18464
14112
      
18465
14113
      // Declare helper variables.
18466
 
      unsigned int rr = 0;
18467
 
      unsigned int ss = 0;
18468
14114
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
18469
14115
      
18470
14116
      // Compute basisvalues.
18471
14117
      basisvalues[0] = 1.0;
18472
14118
      basisvalues[1] = tmp0;
18473
 
      for (unsigned int r = 0; r < 1; r++)
18474
 
      {
18475
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
18476
 
        ss = r*(r + 1)*(r + 2)/6;
18477
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
18478
 
      }// end loop over 'r'
18479
 
      for (unsigned int r = 0; r < 1; r++)
18480
 
      {
18481
 
        for (unsigned int s = 0; s < 1 - r; s++)
18482
 
        {
18483
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
18484
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
18485
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
18486
 
        }// end loop over 's'
18487
 
      }// end loop over 'r'
18488
 
      for (unsigned int r = 0; r < 2; r++)
18489
 
      {
18490
 
        for (unsigned int s = 0; s < 2 - r; s++)
18491
 
        {
18492
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
18493
 
          {
18494
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
18495
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
18496
 
          }// end loop over 't'
18497
 
        }// end loop over 's'
18498
 
      }// end loop over 'r'
 
14119
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
14120
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
14121
      basisvalues[0] *= std::sqrt(0.75);
 
14122
      basisvalues[3] *= std::sqrt(1.25);
 
14123
      basisvalues[2] *= std::sqrt(2.5);
 
14124
      basisvalues[1] *= std::sqrt(7.5);
18499
14125
      
18500
14126
      // Table(s) of coefficients.
18501
14127
      static const double coefficients0[4] = \
18675
14301
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
18676
14302
      
18677
14303
      // Declare helper variables.
18678
 
      unsigned int rr = 0;
18679
 
      unsigned int ss = 0;
18680
14304
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
18681
14305
      
18682
14306
      // Compute basisvalues.
18683
14307
      basisvalues[0] = 1.0;
18684
14308
      basisvalues[1] = tmp0;
18685
 
      for (unsigned int r = 0; r < 1; r++)
18686
 
      {
18687
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
18688
 
        ss = r*(r + 1)*(r + 2)/6;
18689
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
18690
 
      }// end loop over 'r'
18691
 
      for (unsigned int r = 0; r < 1; r++)
18692
 
      {
18693
 
        for (unsigned int s = 0; s < 1 - r; s++)
18694
 
        {
18695
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
18696
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
18697
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
18698
 
        }// end loop over 's'
18699
 
      }// end loop over 'r'
18700
 
      for (unsigned int r = 0; r < 2; r++)
18701
 
      {
18702
 
        for (unsigned int s = 0; s < 2 - r; s++)
18703
 
        {
18704
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
18705
 
          {
18706
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
18707
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
18708
 
          }// end loop over 't'
18709
 
        }// end loop over 's'
18710
 
      }// end loop over 'r'
 
14309
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
14310
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
14311
      basisvalues[0] *= std::sqrt(0.75);
 
14312
      basisvalues[3] *= std::sqrt(1.25);
 
14313
      basisvalues[2] *= std::sqrt(2.5);
 
14314
      basisvalues[1] *= std::sqrt(7.5);
18711
14315
      
18712
14316
      // Table(s) of coefficients.
18713
14317
      static const double coefficients0[4] = \
18887
14491
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
18888
14492
      
18889
14493
      // Declare helper variables.
18890
 
      unsigned int rr = 0;
18891
 
      unsigned int ss = 0;
18892
14494
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
18893
14495
      
18894
14496
      // Compute basisvalues.
18895
14497
      basisvalues[0] = 1.0;
18896
14498
      basisvalues[1] = tmp0;
18897
 
      for (unsigned int r = 0; r < 1; r++)
18898
 
      {
18899
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
18900
 
        ss = r*(r + 1)*(r + 2)/6;
18901
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
18902
 
      }// end loop over 'r'
18903
 
      for (unsigned int r = 0; r < 1; r++)
18904
 
      {
18905
 
        for (unsigned int s = 0; s < 1 - r; s++)
18906
 
        {
18907
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
18908
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
18909
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
18910
 
        }// end loop over 's'
18911
 
      }// end loop over 'r'
18912
 
      for (unsigned int r = 0; r < 2; r++)
18913
 
      {
18914
 
        for (unsigned int s = 0; s < 2 - r; s++)
18915
 
        {
18916
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
18917
 
          {
18918
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
18919
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
18920
 
          }// end loop over 't'
18921
 
        }// end loop over 's'
18922
 
      }// end loop over 'r'
 
14499
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
14500
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
14501
      basisvalues[0] *= std::sqrt(0.75);
 
14502
      basisvalues[3] *= std::sqrt(1.25);
 
14503
      basisvalues[2] *= std::sqrt(2.5);
 
14504
      basisvalues[1] *= std::sqrt(7.5);
18923
14505
      
18924
14506
      // Table(s) of coefficients.
18925
14507
      static const double coefficients0[4] = \
19099
14681
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
19100
14682
      
19101
14683
      // Declare helper variables.
19102
 
      unsigned int rr = 0;
19103
 
      unsigned int ss = 0;
19104
14684
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
19105
14685
      
19106
14686
      // Compute basisvalues.
19107
14687
      basisvalues[0] = 1.0;
19108
14688
      basisvalues[1] = tmp0;
19109
 
      for (unsigned int r = 0; r < 1; r++)
19110
 
      {
19111
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
19112
 
        ss = r*(r + 1)*(r + 2)/6;
19113
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
19114
 
      }// end loop over 'r'
19115
 
      for (unsigned int r = 0; r < 1; r++)
19116
 
      {
19117
 
        for (unsigned int s = 0; s < 1 - r; s++)
19118
 
        {
19119
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
19120
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
19121
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
19122
 
        }// end loop over 's'
19123
 
      }// end loop over 'r'
19124
 
      for (unsigned int r = 0; r < 2; r++)
19125
 
      {
19126
 
        for (unsigned int s = 0; s < 2 - r; s++)
19127
 
        {
19128
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
19129
 
          {
19130
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
19131
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
19132
 
          }// end loop over 't'
19133
 
        }// end loop over 's'
19134
 
      }// end loop over 'r'
 
14689
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
14690
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
14691
      basisvalues[0] *= std::sqrt(0.75);
 
14692
      basisvalues[3] *= std::sqrt(1.25);
 
14693
      basisvalues[2] *= std::sqrt(2.5);
 
14694
      basisvalues[1] *= std::sqrt(7.5);
19135
14695
      
19136
14696
      // Table(s) of coefficients.
19137
14697
      static const double coefficients0[4] = \
19726
15286
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
19727
15287
      
19728
15288
      // Declare helper variables.
19729
 
      unsigned int rr = 0;
19730
 
      unsigned int ss = 0;
19731
15289
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
19732
15290
      
19733
15291
      // Compute basisvalues.
19734
15292
      basisvalues[0] = 1.0;
19735
15293
      basisvalues[1] = tmp0;
19736
 
      for (unsigned int r = 0; r < 1; r++)
19737
 
      {
19738
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
19739
 
        ss = r*(r + 1)*(r + 2)/6;
19740
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
19741
 
      }// end loop over 'r'
19742
 
      for (unsigned int r = 0; r < 1; r++)
19743
 
      {
19744
 
        for (unsigned int s = 0; s < 1 - r; s++)
19745
 
        {
19746
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
19747
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
19748
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
19749
 
        }// end loop over 's'
19750
 
      }// end loop over 'r'
19751
 
      for (unsigned int r = 0; r < 2; r++)
19752
 
      {
19753
 
        for (unsigned int s = 0; s < 2 - r; s++)
19754
 
        {
19755
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
19756
 
          {
19757
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
19758
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
19759
 
          }// end loop over 't'
19760
 
        }// end loop over 's'
19761
 
      }// end loop over 'r'
 
15294
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15295
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15296
      basisvalues[0] *= std::sqrt(0.75);
 
15297
      basisvalues[3] *= std::sqrt(1.25);
 
15298
      basisvalues[2] *= std::sqrt(2.5);
 
15299
      basisvalues[1] *= std::sqrt(7.5);
19762
15300
      
19763
15301
      // Table(s) of coefficients.
19764
15302
      static const double coefficients0[4] = \
19778
15316
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
19779
15317
      
19780
15318
      // Declare helper variables.
19781
 
      unsigned int rr = 0;
19782
 
      unsigned int ss = 0;
19783
15319
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
19784
15320
      
19785
15321
      // Compute basisvalues.
19786
15322
      basisvalues[0] = 1.0;
19787
15323
      basisvalues[1] = tmp0;
19788
 
      for (unsigned int r = 0; r < 1; r++)
19789
 
      {
19790
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
19791
 
        ss = r*(r + 1)*(r + 2)/6;
19792
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
19793
 
      }// end loop over 'r'
19794
 
      for (unsigned int r = 0; r < 1; r++)
19795
 
      {
19796
 
        for (unsigned int s = 0; s < 1 - r; s++)
19797
 
        {
19798
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
19799
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
19800
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
19801
 
        }// end loop over 's'
19802
 
      }// end loop over 'r'
19803
 
      for (unsigned int r = 0; r < 2; r++)
19804
 
      {
19805
 
        for (unsigned int s = 0; s < 2 - r; s++)
19806
 
        {
19807
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
19808
 
          {
19809
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
19810
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
19811
 
          }// end loop over 't'
19812
 
        }// end loop over 's'
19813
 
      }// end loop over 'r'
 
15324
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15325
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15326
      basisvalues[0] *= std::sqrt(0.75);
 
15327
      basisvalues[3] *= std::sqrt(1.25);
 
15328
      basisvalues[2] *= std::sqrt(2.5);
 
15329
      basisvalues[1] *= std::sqrt(7.5);
19814
15330
      
19815
15331
      // Table(s) of coefficients.
19816
15332
      static const double coefficients0[4] = \
19830
15346
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
19831
15347
      
19832
15348
      // Declare helper variables.
19833
 
      unsigned int rr = 0;
19834
 
      unsigned int ss = 0;
19835
15349
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
19836
15350
      
19837
15351
      // Compute basisvalues.
19838
15352
      basisvalues[0] = 1.0;
19839
15353
      basisvalues[1] = tmp0;
19840
 
      for (unsigned int r = 0; r < 1; r++)
19841
 
      {
19842
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
19843
 
        ss = r*(r + 1)*(r + 2)/6;
19844
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
19845
 
      }// end loop over 'r'
19846
 
      for (unsigned int r = 0; r < 1; r++)
19847
 
      {
19848
 
        for (unsigned int s = 0; s < 1 - r; s++)
19849
 
        {
19850
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
19851
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
19852
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
19853
 
        }// end loop over 's'
19854
 
      }// end loop over 'r'
19855
 
      for (unsigned int r = 0; r < 2; r++)
19856
 
      {
19857
 
        for (unsigned int s = 0; s < 2 - r; s++)
19858
 
        {
19859
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
19860
 
          {
19861
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
19862
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
19863
 
          }// end loop over 't'
19864
 
        }// end loop over 's'
19865
 
      }// end loop over 'r'
 
15354
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15355
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15356
      basisvalues[0] *= std::sqrt(0.75);
 
15357
      basisvalues[3] *= std::sqrt(1.25);
 
15358
      basisvalues[2] *= std::sqrt(2.5);
 
15359
      basisvalues[1] *= std::sqrt(7.5);
19866
15360
      
19867
15361
      // Table(s) of coefficients.
19868
15362
      static const double coefficients0[4] = \
19882
15376
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
19883
15377
      
19884
15378
      // Declare helper variables.
19885
 
      unsigned int rr = 0;
19886
 
      unsigned int ss = 0;
19887
15379
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
19888
15380
      
19889
15381
      // Compute basisvalues.
19890
15382
      basisvalues[0] = 1.0;
19891
15383
      basisvalues[1] = tmp0;
19892
 
      for (unsigned int r = 0; r < 1; r++)
19893
 
      {
19894
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
19895
 
        ss = r*(r + 1)*(r + 2)/6;
19896
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
19897
 
      }// end loop over 'r'
19898
 
      for (unsigned int r = 0; r < 1; r++)
19899
 
      {
19900
 
        for (unsigned int s = 0; s < 1 - r; s++)
19901
 
        {
19902
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
19903
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
19904
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
19905
 
        }// end loop over 's'
19906
 
      }// end loop over 'r'
19907
 
      for (unsigned int r = 0; r < 2; r++)
19908
 
      {
19909
 
        for (unsigned int s = 0; s < 2 - r; s++)
19910
 
        {
19911
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
19912
 
          {
19913
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
19914
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
19915
 
          }// end loop over 't'
19916
 
        }// end loop over 's'
19917
 
      }// end loop over 'r'
 
15384
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15385
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15386
      basisvalues[0] *= std::sqrt(0.75);
 
15387
      basisvalues[3] *= std::sqrt(1.25);
 
15388
      basisvalues[2] *= std::sqrt(2.5);
 
15389
      basisvalues[1] *= std::sqrt(7.5);
19918
15390
      
19919
15391
      // Table(s) of coefficients.
19920
15392
      static const double coefficients0[4] = \
19934
15406
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
19935
15407
      
19936
15408
      // Declare helper variables.
19937
 
      unsigned int rr = 0;
19938
 
      unsigned int ss = 0;
19939
15409
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
19940
15410
      
19941
15411
      // Compute basisvalues.
19942
15412
      basisvalues[0] = 1.0;
19943
15413
      basisvalues[1] = tmp0;
19944
 
      for (unsigned int r = 0; r < 1; r++)
19945
 
      {
19946
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
19947
 
        ss = r*(r + 1)*(r + 2)/6;
19948
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
19949
 
      }// end loop over 'r'
19950
 
      for (unsigned int r = 0; r < 1; r++)
19951
 
      {
19952
 
        for (unsigned int s = 0; s < 1 - r; s++)
19953
 
        {
19954
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
19955
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
19956
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
19957
 
        }// end loop over 's'
19958
 
      }// end loop over 'r'
19959
 
      for (unsigned int r = 0; r < 2; r++)
19960
 
      {
19961
 
        for (unsigned int s = 0; s < 2 - r; s++)
19962
 
        {
19963
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
19964
 
          {
19965
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
19966
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
19967
 
          }// end loop over 't'
19968
 
        }// end loop over 's'
19969
 
      }// end loop over 'r'
 
15414
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15415
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15416
      basisvalues[0] *= std::sqrt(0.75);
 
15417
      basisvalues[3] *= std::sqrt(1.25);
 
15418
      basisvalues[2] *= std::sqrt(2.5);
 
15419
      basisvalues[1] *= std::sqrt(7.5);
19970
15420
      
19971
15421
      // Table(s) of coefficients.
19972
15422
      static const double coefficients0[4] = \
20002
15452
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
20003
15453
      
20004
15454
      // Declare helper variables.
20005
 
      unsigned int rr = 0;
20006
 
      unsigned int ss = 0;
20007
15455
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
20008
15456
      
20009
15457
      // Compute basisvalues.
20010
15458
      basisvalues[0] = 1.0;
20011
15459
      basisvalues[1] = tmp0;
20012
 
      for (unsigned int r = 0; r < 1; r++)
20013
 
      {
20014
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
20015
 
        ss = r*(r + 1)*(r + 2)/6;
20016
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
20017
 
      }// end loop over 'r'
20018
 
      for (unsigned int r = 0; r < 1; r++)
20019
 
      {
20020
 
        for (unsigned int s = 0; s < 1 - r; s++)
20021
 
        {
20022
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
20023
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
20024
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
20025
 
        }// end loop over 's'
20026
 
      }// end loop over 'r'
20027
 
      for (unsigned int r = 0; r < 2; r++)
20028
 
      {
20029
 
        for (unsigned int s = 0; s < 2 - r; s++)
20030
 
        {
20031
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
20032
 
          {
20033
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
20034
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
20035
 
          }// end loop over 't'
20036
 
        }// end loop over 's'
20037
 
      }// end loop over 'r'
 
15460
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15461
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15462
      basisvalues[0] *= std::sqrt(0.75);
 
15463
      basisvalues[3] *= std::sqrt(1.25);
 
15464
      basisvalues[2] *= std::sqrt(2.5);
 
15465
      basisvalues[1] *= std::sqrt(7.5);
20038
15466
      
20039
15467
      // Table(s) of coefficients.
20040
15468
      static const double coefficients0[4] = \
20070
15498
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
20071
15499
      
20072
15500
      // Declare helper variables.
20073
 
      unsigned int rr = 0;
20074
 
      unsigned int ss = 0;
20075
15501
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
20076
15502
      
20077
15503
      // Compute basisvalues.
20078
15504
      basisvalues[0] = 1.0;
20079
15505
      basisvalues[1] = tmp0;
20080
 
      for (unsigned int r = 0; r < 1; r++)
20081
 
      {
20082
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
20083
 
        ss = r*(r + 1)*(r + 2)/6;
20084
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
20085
 
      }// end loop over 'r'
20086
 
      for (unsigned int r = 0; r < 1; r++)
20087
 
      {
20088
 
        for (unsigned int s = 0; s < 1 - r; s++)
20089
 
        {
20090
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
20091
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
20092
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
20093
 
        }// end loop over 's'
20094
 
      }// end loop over 'r'
20095
 
      for (unsigned int r = 0; r < 2; r++)
20096
 
      {
20097
 
        for (unsigned int s = 0; s < 2 - r; s++)
20098
 
        {
20099
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
20100
 
          {
20101
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
20102
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
20103
 
          }// end loop over 't'
20104
 
        }// end loop over 's'
20105
 
      }// end loop over 'r'
 
15506
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15507
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15508
      basisvalues[0] *= std::sqrt(0.75);
 
15509
      basisvalues[3] *= std::sqrt(1.25);
 
15510
      basisvalues[2] *= std::sqrt(2.5);
 
15511
      basisvalues[1] *= std::sqrt(7.5);
20106
15512
      
20107
15513
      // Table(s) of coefficients.
20108
15514
      static const double coefficients0[4] = \
20138
15544
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
20139
15545
      
20140
15546
      // Declare helper variables.
20141
 
      unsigned int rr = 0;
20142
 
      unsigned int ss = 0;
20143
15547
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
20144
15548
      
20145
15549
      // Compute basisvalues.
20146
15550
      basisvalues[0] = 1.0;
20147
15551
      basisvalues[1] = tmp0;
20148
 
      for (unsigned int r = 0; r < 1; r++)
20149
 
      {
20150
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
20151
 
        ss = r*(r + 1)*(r + 2)/6;
20152
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
20153
 
      }// end loop over 'r'
20154
 
      for (unsigned int r = 0; r < 1; r++)
20155
 
      {
20156
 
        for (unsigned int s = 0; s < 1 - r; s++)
20157
 
        {
20158
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
20159
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
20160
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
20161
 
        }// end loop over 's'
20162
 
      }// end loop over 'r'
20163
 
      for (unsigned int r = 0; r < 2; r++)
20164
 
      {
20165
 
        for (unsigned int s = 0; s < 2 - r; s++)
20166
 
        {
20167
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
20168
 
          {
20169
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
20170
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
20171
 
          }// end loop over 't'
20172
 
        }// end loop over 's'
20173
 
      }// end loop over 'r'
 
15552
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15553
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15554
      basisvalues[0] *= std::sqrt(0.75);
 
15555
      basisvalues[3] *= std::sqrt(1.25);
 
15556
      basisvalues[2] *= std::sqrt(2.5);
 
15557
      basisvalues[1] *= std::sqrt(7.5);
20174
15558
      
20175
15559
      // Table(s) of coefficients.
20176
15560
      static const double coefficients0[4] = \
20206
15590
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
20207
15591
      
20208
15592
      // Declare helper variables.
20209
 
      unsigned int rr = 0;
20210
 
      unsigned int ss = 0;
20211
15593
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
20212
15594
      
20213
15595
      // Compute basisvalues.
20214
15596
      basisvalues[0] = 1.0;
20215
15597
      basisvalues[1] = tmp0;
20216
 
      for (unsigned int r = 0; r < 1; r++)
20217
 
      {
20218
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
20219
 
        ss = r*(r + 1)*(r + 2)/6;
20220
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
20221
 
      }// end loop over 'r'
20222
 
      for (unsigned int r = 0; r < 1; r++)
20223
 
      {
20224
 
        for (unsigned int s = 0; s < 1 - r; s++)
20225
 
        {
20226
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
20227
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
20228
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
20229
 
        }// end loop over 's'
20230
 
      }// end loop over 'r'
20231
 
      for (unsigned int r = 0; r < 2; r++)
20232
 
      {
20233
 
        for (unsigned int s = 0; s < 2 - r; s++)
20234
 
        {
20235
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
20236
 
          {
20237
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
20238
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
20239
 
          }// end loop over 't'
20240
 
        }// end loop over 's'
20241
 
      }// end loop over 'r'
 
15598
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15599
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15600
      basisvalues[0] *= std::sqrt(0.75);
 
15601
      basisvalues[3] *= std::sqrt(1.25);
 
15602
      basisvalues[2] *= std::sqrt(2.5);
 
15603
      basisvalues[1] *= std::sqrt(7.5);
20242
15604
      
20243
15605
      // Table(s) of coefficients.
20244
15606
      static const double coefficients0[4] = \
20274
15636
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
20275
15637
      
20276
15638
      // Declare helper variables.
20277
 
      unsigned int rr = 0;
20278
 
      unsigned int ss = 0;
20279
15639
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
20280
15640
      
20281
15641
      // Compute basisvalues.
20282
15642
      basisvalues[0] = 1.0;
20283
15643
      basisvalues[1] = tmp0;
20284
 
      for (unsigned int r = 0; r < 1; r++)
20285
 
      {
20286
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
20287
 
        ss = r*(r + 1)*(r + 2)/6;
20288
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
20289
 
      }// end loop over 'r'
20290
 
      for (unsigned int r = 0; r < 1; r++)
20291
 
      {
20292
 
        for (unsigned int s = 0; s < 1 - r; s++)
20293
 
        {
20294
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
20295
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
20296
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
20297
 
        }// end loop over 's'
20298
 
      }// end loop over 'r'
20299
 
      for (unsigned int r = 0; r < 2; r++)
20300
 
      {
20301
 
        for (unsigned int s = 0; s < 2 - r; s++)
20302
 
        {
20303
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
20304
 
          {
20305
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
20306
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
20307
 
          }// end loop over 't'
20308
 
        }// end loop over 's'
20309
 
      }// end loop over 'r'
 
15644
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15645
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15646
      basisvalues[0] *= std::sqrt(0.75);
 
15647
      basisvalues[3] *= std::sqrt(1.25);
 
15648
      basisvalues[2] *= std::sqrt(2.5);
 
15649
      basisvalues[1] *= std::sqrt(7.5);
20310
15650
      
20311
15651
      // Table(s) of coefficients.
20312
15652
      static const double coefficients0[4] = \
20488
15828
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
20489
15829
      
20490
15830
      // Declare helper variables.
20491
 
      unsigned int rr = 0;
20492
 
      unsigned int ss = 0;
20493
15831
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
20494
15832
      
20495
15833
      // Compute basisvalues.
20496
15834
      basisvalues[0] = 1.0;
20497
15835
      basisvalues[1] = tmp0;
20498
 
      for (unsigned int r = 0; r < 1; r++)
20499
 
      {
20500
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
20501
 
        ss = r*(r + 1)*(r + 2)/6;
20502
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
20503
 
      }// end loop over 'r'
20504
 
      for (unsigned int r = 0; r < 1; r++)
20505
 
      {
20506
 
        for (unsigned int s = 0; s < 1 - r; s++)
20507
 
        {
20508
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
20509
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
20510
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
20511
 
        }// end loop over 's'
20512
 
      }// end loop over 'r'
20513
 
      for (unsigned int r = 0; r < 2; r++)
20514
 
      {
20515
 
        for (unsigned int s = 0; s < 2 - r; s++)
20516
 
        {
20517
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
20518
 
          {
20519
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
20520
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
20521
 
          }// end loop over 't'
20522
 
        }// end loop over 's'
20523
 
      }// end loop over 'r'
 
15836
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
15837
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
15838
      basisvalues[0] *= std::sqrt(0.75);
 
15839
      basisvalues[3] *= std::sqrt(1.25);
 
15840
      basisvalues[2] *= std::sqrt(2.5);
 
15841
      basisvalues[1] *= std::sqrt(7.5);
20524
15842
      
20525
15843
      // Table(s) of coefficients.
20526
15844
      static const double coefficients0[4] = \
20682
16000
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
20683
16001
      
20684
16002
      // Declare helper variables.
20685
 
      unsigned int rr = 0;
20686
 
      unsigned int ss = 0;
20687
16003
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
20688
16004
      
20689
16005
      // Compute basisvalues.
20690
16006
      basisvalues[0] = 1.0;
20691
16007
      basisvalues[1] = tmp0;
20692
 
      for (unsigned int r = 0; r < 1; r++)
20693
 
      {
20694
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
20695
 
        ss = r*(r + 1)*(r + 2)/6;
20696
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
20697
 
      }// end loop over 'r'
20698
 
      for (unsigned int r = 0; r < 1; r++)
20699
 
      {
20700
 
        for (unsigned int s = 0; s < 1 - r; s++)
20701
 
        {
20702
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
20703
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
20704
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
20705
 
        }// end loop over 's'
20706
 
      }// end loop over 'r'
20707
 
      for (unsigned int r = 0; r < 2; r++)
20708
 
      {
20709
 
        for (unsigned int s = 0; s < 2 - r; s++)
20710
 
        {
20711
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
20712
 
          {
20713
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
20714
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
20715
 
          }// end loop over 't'
20716
 
        }// end loop over 's'
20717
 
      }// end loop over 'r'
 
16008
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
16009
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
16010
      basisvalues[0] *= std::sqrt(0.75);
 
16011
      basisvalues[3] *= std::sqrt(1.25);
 
16012
      basisvalues[2] *= std::sqrt(2.5);
 
16013
      basisvalues[1] *= std::sqrt(7.5);
20718
16014
      
20719
16015
      // Table(s) of coefficients.
20720
16016
      static const double coefficients0[4] = \
20876
16172
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
20877
16173
      
20878
16174
      // Declare helper variables.
20879
 
      unsigned int rr = 0;
20880
 
      unsigned int ss = 0;
20881
16175
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
20882
16176
      
20883
16177
      // Compute basisvalues.
20884
16178
      basisvalues[0] = 1.0;
20885
16179
      basisvalues[1] = tmp0;
20886
 
      for (unsigned int r = 0; r < 1; r++)
20887
 
      {
20888
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
20889
 
        ss = r*(r + 1)*(r + 2)/6;
20890
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
20891
 
      }// end loop over 'r'
20892
 
      for (unsigned int r = 0; r < 1; r++)
20893
 
      {
20894
 
        for (unsigned int s = 0; s < 1 - r; s++)
20895
 
        {
20896
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
20897
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
20898
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
20899
 
        }// end loop over 's'
20900
 
      }// end loop over 'r'
20901
 
      for (unsigned int r = 0; r < 2; r++)
20902
 
      {
20903
 
        for (unsigned int s = 0; s < 2 - r; s++)
20904
 
        {
20905
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
20906
 
          {
20907
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
20908
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
20909
 
          }// end loop over 't'
20910
 
        }// end loop over 's'
20911
 
      }// end loop over 'r'
 
16180
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
16181
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
16182
      basisvalues[0] *= std::sqrt(0.75);
 
16183
      basisvalues[3] *= std::sqrt(1.25);
 
16184
      basisvalues[2] *= std::sqrt(2.5);
 
16185
      basisvalues[1] *= std::sqrt(7.5);
20912
16186
      
20913
16187
      // Table(s) of coefficients.
20914
16188
      static const double coefficients0[4] = \
21070
16344
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
21071
16345
      
21072
16346
      // Declare helper variables.
21073
 
      unsigned int rr = 0;
21074
 
      unsigned int ss = 0;
21075
16347
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
21076
16348
      
21077
16349
      // Compute basisvalues.
21078
16350
      basisvalues[0] = 1.0;
21079
16351
      basisvalues[1] = tmp0;
21080
 
      for (unsigned int r = 0; r < 1; r++)
21081
 
      {
21082
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
21083
 
        ss = r*(r + 1)*(r + 2)/6;
21084
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
21085
 
      }// end loop over 'r'
21086
 
      for (unsigned int r = 0; r < 1; r++)
21087
 
      {
21088
 
        for (unsigned int s = 0; s < 1 - r; s++)
21089
 
        {
21090
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
21091
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
21092
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
21093
 
        }// end loop over 's'
21094
 
      }// end loop over 'r'
21095
 
      for (unsigned int r = 0; r < 2; r++)
21096
 
      {
21097
 
        for (unsigned int s = 0; s < 2 - r; s++)
21098
 
        {
21099
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
21100
 
          {
21101
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
21102
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
21103
 
          }// end loop over 't'
21104
 
        }// end loop over 's'
21105
 
      }// end loop over 'r'
 
16352
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
16353
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
16354
      basisvalues[0] *= std::sqrt(0.75);
 
16355
      basisvalues[3] *= std::sqrt(1.25);
 
16356
      basisvalues[2] *= std::sqrt(2.5);
 
16357
      basisvalues[1] *= std::sqrt(7.5);
21106
16358
      
21107
16359
      // Table(s) of coefficients.
21108
16360
      static const double coefficients0[4] = \
21264
16516
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
21265
16517
      
21266
16518
      // Declare helper variables.
21267
 
      unsigned int rr = 0;
21268
 
      unsigned int ss = 0;
21269
16519
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
21270
16520
      
21271
16521
      // Compute basisvalues.
21272
16522
      basisvalues[0] = 1.0;
21273
16523
      basisvalues[1] = tmp0;
21274
 
      for (unsigned int r = 0; r < 1; r++)
21275
 
      {
21276
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
21277
 
        ss = r*(r + 1)*(r + 2)/6;
21278
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
21279
 
      }// end loop over 'r'
21280
 
      for (unsigned int r = 0; r < 1; r++)
21281
 
      {
21282
 
        for (unsigned int s = 0; s < 1 - r; s++)
21283
 
        {
21284
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
21285
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
21286
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
21287
 
        }// end loop over 's'
21288
 
      }// end loop over 'r'
21289
 
      for (unsigned int r = 0; r < 2; r++)
21290
 
      {
21291
 
        for (unsigned int s = 0; s < 2 - r; s++)
21292
 
        {
21293
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
21294
 
          {
21295
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
21296
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
21297
 
          }// end loop over 't'
21298
 
        }// end loop over 's'
21299
 
      }// end loop over 'r'
 
16524
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
16525
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
16526
      basisvalues[0] *= std::sqrt(0.75);
 
16527
      basisvalues[3] *= std::sqrt(1.25);
 
16528
      basisvalues[2] *= std::sqrt(2.5);
 
16529
      basisvalues[1] *= std::sqrt(7.5);
21300
16530
      
21301
16531
      // Table(s) of coefficients.
21302
16532
      static const double coefficients0[4] = \
21476
16706
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
21477
16707
      
21478
16708
      // Declare helper variables.
21479
 
      unsigned int rr = 0;
21480
 
      unsigned int ss = 0;
21481
16709
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
21482
16710
      
21483
16711
      // Compute basisvalues.
21484
16712
      basisvalues[0] = 1.0;
21485
16713
      basisvalues[1] = tmp0;
21486
 
      for (unsigned int r = 0; r < 1; r++)
21487
 
      {
21488
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
21489
 
        ss = r*(r + 1)*(r + 2)/6;
21490
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
21491
 
      }// end loop over 'r'
21492
 
      for (unsigned int r = 0; r < 1; r++)
21493
 
      {
21494
 
        for (unsigned int s = 0; s < 1 - r; s++)
21495
 
        {
21496
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
21497
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
21498
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
21499
 
        }// end loop over 's'
21500
 
      }// end loop over 'r'
21501
 
      for (unsigned int r = 0; r < 2; r++)
21502
 
      {
21503
 
        for (unsigned int s = 0; s < 2 - r; s++)
21504
 
        {
21505
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
21506
 
          {
21507
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
21508
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
21509
 
          }// end loop over 't'
21510
 
        }// end loop over 's'
21511
 
      }// end loop over 'r'
 
16714
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
16715
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
16716
      basisvalues[0] *= std::sqrt(0.75);
 
16717
      basisvalues[3] *= std::sqrt(1.25);
 
16718
      basisvalues[2] *= std::sqrt(2.5);
 
16719
      basisvalues[1] *= std::sqrt(7.5);
21512
16720
      
21513
16721
      // Table(s) of coefficients.
21514
16722
      static const double coefficients0[4] = \
21688
16896
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
21689
16897
      
21690
16898
      // Declare helper variables.
21691
 
      unsigned int rr = 0;
21692
 
      unsigned int ss = 0;
21693
16899
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
21694
16900
      
21695
16901
      // Compute basisvalues.
21696
16902
      basisvalues[0] = 1.0;
21697
16903
      basisvalues[1] = tmp0;
21698
 
      for (unsigned int r = 0; r < 1; r++)
21699
 
      {
21700
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
21701
 
        ss = r*(r + 1)*(r + 2)/6;
21702
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
21703
 
      }// end loop over 'r'
21704
 
      for (unsigned int r = 0; r < 1; r++)
21705
 
      {
21706
 
        for (unsigned int s = 0; s < 1 - r; s++)
21707
 
        {
21708
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
21709
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
21710
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
21711
 
        }// end loop over 's'
21712
 
      }// end loop over 'r'
21713
 
      for (unsigned int r = 0; r < 2; r++)
21714
 
      {
21715
 
        for (unsigned int s = 0; s < 2 - r; s++)
21716
 
        {
21717
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
21718
 
          {
21719
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
21720
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
21721
 
          }// end loop over 't'
21722
 
        }// end loop over 's'
21723
 
      }// end loop over 'r'
 
16904
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
16905
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
16906
      basisvalues[0] *= std::sqrt(0.75);
 
16907
      basisvalues[3] *= std::sqrt(1.25);
 
16908
      basisvalues[2] *= std::sqrt(2.5);
 
16909
      basisvalues[1] *= std::sqrt(7.5);
21724
16910
      
21725
16911
      // Table(s) of coefficients.
21726
16912
      static const double coefficients0[4] = \
21900
17086
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
21901
17087
      
21902
17088
      // Declare helper variables.
21903
 
      unsigned int rr = 0;
21904
 
      unsigned int ss = 0;
21905
17089
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
21906
17090
      
21907
17091
      // Compute basisvalues.
21908
17092
      basisvalues[0] = 1.0;
21909
17093
      basisvalues[1] = tmp0;
21910
 
      for (unsigned int r = 0; r < 1; r++)
21911
 
      {
21912
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
21913
 
        ss = r*(r + 1)*(r + 2)/6;
21914
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
21915
 
      }// end loop over 'r'
21916
 
      for (unsigned int r = 0; r < 1; r++)
21917
 
      {
21918
 
        for (unsigned int s = 0; s < 1 - r; s++)
21919
 
        {
21920
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
21921
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
21922
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
21923
 
        }// end loop over 's'
21924
 
      }// end loop over 'r'
21925
 
      for (unsigned int r = 0; r < 2; r++)
21926
 
      {
21927
 
        for (unsigned int s = 0; s < 2 - r; s++)
21928
 
        {
21929
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
21930
 
          {
21931
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
21932
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
21933
 
          }// end loop over 't'
21934
 
        }// end loop over 's'
21935
 
      }// end loop over 'r'
 
17094
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
17095
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
17096
      basisvalues[0] *= std::sqrt(0.75);
 
17097
      basisvalues[3] *= std::sqrt(1.25);
 
17098
      basisvalues[2] *= std::sqrt(2.5);
 
17099
      basisvalues[1] *= std::sqrt(7.5);
21936
17100
      
21937
17101
      // Table(s) of coefficients.
21938
17102
      static const double coefficients0[4] = \
22112
17276
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
22113
17277
      
22114
17278
      // Declare helper variables.
22115
 
      unsigned int rr = 0;
22116
 
      unsigned int ss = 0;
22117
17279
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
22118
17280
      
22119
17281
      // Compute basisvalues.
22120
17282
      basisvalues[0] = 1.0;
22121
17283
      basisvalues[1] = tmp0;
22122
 
      for (unsigned int r = 0; r < 1; r++)
22123
 
      {
22124
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
22125
 
        ss = r*(r + 1)*(r + 2)/6;
22126
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
22127
 
      }// end loop over 'r'
22128
 
      for (unsigned int r = 0; r < 1; r++)
22129
 
      {
22130
 
        for (unsigned int s = 0; s < 1 - r; s++)
22131
 
        {
22132
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
22133
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
22134
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
22135
 
        }// end loop over 's'
22136
 
      }// end loop over 'r'
22137
 
      for (unsigned int r = 0; r < 2; r++)
22138
 
      {
22139
 
        for (unsigned int s = 0; s < 2 - r; s++)
22140
 
        {
22141
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
22142
 
          {
22143
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
22144
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
22145
 
          }// end loop over 't'
22146
 
        }// end loop over 's'
22147
 
      }// end loop over 'r'
 
17284
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
17285
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
17286
      basisvalues[0] *= std::sqrt(0.75);
 
17287
      basisvalues[3] *= std::sqrt(1.25);
 
17288
      basisvalues[2] *= std::sqrt(2.5);
 
17289
      basisvalues[1] *= std::sqrt(7.5);
22148
17290
      
22149
17291
      // Table(s) of coefficients.
22150
17292
      static const double coefficients0[4] = \
22324
17466
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
22325
17467
      
22326
17468
      // Declare helper variables.
22327
 
      unsigned int rr = 0;
22328
 
      unsigned int ss = 0;
22329
17469
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
22330
17470
      
22331
17471
      // Compute basisvalues.
22332
17472
      basisvalues[0] = 1.0;
22333
17473
      basisvalues[1] = tmp0;
22334
 
      for (unsigned int r = 0; r < 1; r++)
22335
 
      {
22336
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
22337
 
        ss = r*(r + 1)*(r + 2)/6;
22338
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
22339
 
      }// end loop over 'r'
22340
 
      for (unsigned int r = 0; r < 1; r++)
22341
 
      {
22342
 
        for (unsigned int s = 0; s < 1 - r; s++)
22343
 
        {
22344
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
22345
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
22346
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
22347
 
        }// end loop over 's'
22348
 
      }// end loop over 'r'
22349
 
      for (unsigned int r = 0; r < 2; r++)
22350
 
      {
22351
 
        for (unsigned int s = 0; s < 2 - r; s++)
22352
 
        {
22353
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
22354
 
          {
22355
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
22356
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
22357
 
          }// end loop over 't'
22358
 
        }// end loop over 's'
22359
 
      }// end loop over 'r'
 
17474
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
17475
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
17476
      basisvalues[0] *= std::sqrt(0.75);
 
17477
      basisvalues[3] *= std::sqrt(1.25);
 
17478
      basisvalues[2] *= std::sqrt(2.5);
 
17479
      basisvalues[1] *= std::sqrt(7.5);
22360
17480
      
22361
17481
      // Table(s) of coefficients.
22362
17482
      static const double coefficients0[4] = \