void ApplicationOP2A::TimeIntegrateImplicitPoint() { int VAR = grid.cells[1].data1D(0).numData; int index_J_inv_plus = 0; int index_J_inv_minus = 1; // [PRE] Initialize Matrix Math::MATRIX matrix_temp1(VAR, VAR, false); matrix_temp1.zeros(); Math::MATRIX matrix_temp2(VAR, 1, false); matrix_temp2.zeros(); vector<Math::MATRIX> M_cl(grid.NCM+1, matrix_temp1); vector<Math::MATRIX> B(grid.NCM+1, matrix_temp1); vector<Math::MATRIX> B_inv(grid.NCM+1, matrix_temp1); vector<Math::MATRIX> R(grid.NCM+1, matrix_temp2); vector<Math::MATRIX> X(grid.NCM+1, matrix_temp2); // STEP 1: Set-up matrix M_CL and R_CL if (problem_setup.is_axisymmetric == true) { #pragma omp parallel for for (int c = 1; c <= grid.NCM; c++) { double Vol = grid.cells[c].geo.S * Math::fabs<double>(grid.cells[c].geo.x[1]); double Vol_dt = Vol / dt; #pragma ivdep for (int r = 0; r <= VAR-1; r++) { #pragma ivdep for (int l = 0; l <= VAR-1; l++) { M_cl[c](r, l) = -grid.cells[c].data2D(1)(r,l); } } #pragma ivdep for (int r = 0; r <= VAR-1; r++) { M_cl[c](r, r) += Vol_dt; } #pragma ivdep for (int r = 0; r <= VAR-1; r++) { R[c](r,0) = -grid.cells[c].data1D(indexResidue)(r); } } } else { #pragma omp parallel for for (int c = 1; c <= grid.NCM; c++) { double Vol = grid.cells[c].geo.S; double Vol_dt = Vol / dt; #pragma ivdep for (int r = 0; r <= VAR-1; r++) { #pragma ivdep for (int l = 0; l <= VAR-1; l++) { M_cl[c](r, l) = -grid.cells[c].data2D(1)(r,l); } } #pragma ivdep for (int r = 0; r <= VAR-1; r++) { M_cl[c](r, r) += Vol_dt; } #pragma ivdep for (int r = 0; r <= VAR-1; r++) { R[c](r,0) = -grid.cells[c].data1D(indexResidue)(r); } } } // SETP 2: ADD Viscous/inviscid Jacobian #pragma omp parallel for for (int c = 1; c <= grid.NCM; c++) { for (int f = 0; f <= grid.cells[c].geo.NF-1; f++) { if (grid.cells[c].geo.face_list[f]->geo.cl[0]->geo.ID == grid.cells[c].geo.ID) { for (int j = 0; j <= VAR-1; j++) { for (int k = 0; k <= VAR-1; k++) { M_cl[c](j, k) += grid.cells[c].geo.face_list[f]->data2D(index_J_inv_plus)(j,k); } } } if (grid.cells[c].geo.face_list[f]->geo.cr[0]->geo.ID == grid.cells[c].geo.ID) { for (int j = 0; j <= VAR-1; j++) { for (int k = 0; k <= VAR-1; k++) { M_cl[c](j, k) += -grid.cells[c].geo.face_list[f]->data2D(index_J_inv_minus)(j,k); } } } } } // @todo: Need to add Viscous // STEP 6 SOLVE BLOCK TRI-DIAGONAL MATRIX // 6.1. Initialize B = M_cl; #pragma omp parallel for for (int i = 1; i <= grid.NCM; i++) { B_inv[i] = MATRIX_Inv(B[i]); } // 6.2 Solve // 1. Initial solution #pragma omp parallel for num_threads(CFD_NT) for (int i = 1; i <= grid.NCM; i++) { X[i] = B_inv[i] * R[i]; #pragma ivdep for (int r = 0; r <= VAR-1; r++) { if(X[i](r,0) != X[i](r,0)) { std::ostringstream oss; oss << "It has NaN value: [Cell ID]: " << i << " [VAR]: " << r; throw Common::ExceptionNaNValue (FromHere(), oss.str()); } } } #pragma omp parallel for num_threads(CFD_NT) for (int c = 1; c <= grid.NCM; c++) { #pragma ivdep for (int j = 0; j <= VAR-1; j++) { grid.cells[c].data1D(indexdQ)(j) = X[c](j, 0); } } for (int p = 1; p <= 3; p++) { #pragma omp parallel for num_threads(CFD_NT) for (int c = 1; c <= grid.NCM; c++) { #pragma ivdep for (int r = 0; r <= VAR-1; r++) { R[c](r,0) = -grid.cells[c].data1D(indexResidue)(r); } } // STep 2 Communication (FOR MPI) // @todo: Need to update for MPI // Step 3. Update R(n, p) #pragma omp parallel for num_threads(CFD_NT) for (int c = 1; c <= grid.NCM; c++) { for (int k = 0; k <= grid.cells[c].geo.NF-1; k++) { if (grid.cells[c].geo.face_list[k]->geo.cl[0]->geo.ID == grid.cells[c].geo.ID) { if (grid.cells[c].geo.face_list[k]->geo.cr[0]->geo.ID > 0) { #pragma ivdep for (int j = 0; j <= VAR-1; j++) { double aux = 0.0; for (int l = 0; l <= VAR-1; l++) { aux += grid.cells[c].geo.face_list[k]->data2D(index_J_inv_minus)(j,l) * grid.cells[c].geo.face_list[k]->geo.cr[0]->data1D(indexdQ)(l); } R[c](j, 0) -= aux; } } } if (grid.cells[c].geo.face_list[k]->geo.cr[0]->geo.ID == grid.cells[c].geo.ID) { if (grid.cells[c].geo.face_list[k]->geo.cl[0]->geo.ID > 0) { #pragma ivdep for (int j = 0; j <= VAR-1; j++) { double aux = 0.0; for (int l = 0; l <= VAR-1; l++) { aux += grid.cells[c].geo.face_list[k]->data2D(index_J_inv_plus)(j,l) * grid.cells[c].geo.face_list[k]->geo.cl[0]->data1D(indexdQ)(l); } R[c](j, 0) += aux; } } } } } #pragma omp parallel for num_threads(CFD_NT) for (int i = 1; i <= grid.NCM; i++) { X[i] = B_inv[i] * R[i]; } #pragma omp parallel for num_threads(CFD_NT) for (int i = 1; i <= grid.NCM; i++) { #pragma ivdep for (int r = 0; r <= VAR-1; r++) { if(X[i](r,0) != X[i](r,0)) { std::ostringstream oss; oss << "It has NaN value: [Cell ID]: " << i << " [VAR]: " << r; throw Common::ExceptionNaNValue (FromHere(), oss.str()); } grid.cells[i].data1D(indexdQ)(r) = X[i](r,0); } } } }
GlobalsArray::GlobalsArray(NameValueTable* tab) : ArrayData(kGlobalsKind) , m_tab(tab) { Variant arr(staticEmptyArray()); #define X(s,v) tab->set(makeStaticString(#s), v.asTypedValue()); X(argc, init_null_variant); X(argv, init_null_variant); X(_SERVER, arr); X(_GET, arr); X(_POST, arr); X(_COOKIE, arr); X(_FILES, arr); X(_ENV, arr); X(_REQUEST, arr); X(_SESSION, arr); X(HTTP_RAW_POST_DATA, init_null_variant); #undef X g_variables.set(this); assert(hasExactlyOneRef()); }
/* Subroutine */ int clargv_(integer *n, complex *x, integer *incx, complex * y, integer *incy, real *c, integer *incc) { /* -- LAPACK auxiliary routine (version 2.0) -- Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., Courant Institute, Argonne National Lab, and Rice University February 29, 1992 Purpose ======= CLARGV generates a vector of complex plane rotations with real cosines, determined by elements of the complex vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( a(i) ) ( -conjg(s(i)) c(i) ) ( y(i) ) = ( 0 ) Arguments ========= N (input) INTEGER The number of plane rotations to be generated. X (input/output) COMPLEX array, dimension (1+(N-1)*INCX) On entry, the vector x. On exit, x(i) is overwritten by a(i), for i = 1,...,n. INCX (input) INTEGER The increment between elements of X. INCX > 0. Y (input/output) COMPLEX array, dimension (1+(N-1)*INCY) On entry, the vector y. On exit, the sines of the plane rotations. INCY (input) INTEGER The increment between elements of Y. INCY > 0. C (output) REAL array, dimension (1+(N-1)*INCC) The cosines of the plane rotations. INCC (input) INTEGER The increment between elements of C. INCC > 0. ===================================================================== Parameter adjustments Function Body */ /* System generated locals */ integer i__1, i__2; doublereal d__1; complex q__1, q__2, q__3; /* Builtin functions */ double c_abs(complex *), sqrt(doublereal); void r_cnjg(complex *, complex *); /* Local variables */ static real absx, absy; static integer i; static complex t; static real w; static integer ic, ix, iy; static complex xi, yi; static real tt; #define C(I) c[(I)-1] #define Y(I) y[(I)-1] #define X(I) x[(I)-1] ix = 1; iy = 1; ic = 1; i__1 = *n; for (i = 1; i <= *n; ++i) { i__2 = ix; xi.r = X(ix).r, xi.i = X(ix).i; i__2 = iy; yi.r = Y(iy).r, yi.i = Y(iy).i; absx = c_abs(&xi); if (absx == 0.f) { C(ic) = 0.f; i__2 = iy; Y(iy).r = 1.f, Y(iy).i = 0.f; i__2 = ix; X(ix).r = yi.r, X(ix).i = yi.i; } else { absy = c_abs(&yi); w = dmax(absx,absy); q__1.r = xi.r / absx, q__1.i = xi.i / absx; t.r = q__1.r, t.i = q__1.i; absx /= w; absy /= w; tt = sqrt(absx * absx + absy * absy); C(ic) = absx / tt; i__2 = iy; r_cnjg(&q__3, &yi); q__2.r = t.r * q__3.r - t.i * q__3.i, q__2.i = t.r * q__3.i + t.i * q__3.r; d__1 = w * tt; q__1.r = q__2.r / d__1, q__1.i = q__2.i / d__1; Y(iy).r = q__1.r, Y(iy).i = q__1.i; i__2 = ix; d__1 = w * tt; q__1.r = d__1 * t.r, q__1.i = d__1 * t.i; X(ix).r = q__1.r, X(ix).i = q__1.i; } ix += *incx; iy += *incy; ic += *incc; /* L10: */ } return 0; /* End of CLARGV */ } /* clargv_ */
void XSIMD(codelet_t1sv_16) (planner *p) { X(kdft_dit_register) (p, t1sv_16, &desc); }
void X(codelet_t1_3) (planner *p) { X(kdft_dit_register) (p, t1_3, &desc); }
void md5_block_data_order (MD5_CTX *c, const void *data_, int num) { const unsigned char *data=data_; register unsigned long A,B,C,D,l; /* * In case you wonder why A-D are declared as long and not * as MD5_LONG. Doing so results in slight performance * boost on LP64 architectures. The catch is we don't * really care if 32 MSBs of a 64-bit register get polluted * with eventual overflows as we *save* only 32 LSBs in * *either* case. Now declaring 'em long excuses the compiler * from keeping 32 MSBs zeroed resulting in 13% performance * improvement under SPARC Solaris7/64 and 5% under AlphaLinux. * Well, to be honest it should say that this *prevents* * performance degradation. * * <*****@*****.**> */ #ifndef MD32_XARRAY /* See comment in crypto/sha/sha_locl.h for details. */ unsigned long XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7, XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15; # define X(i) XX##i #else MD5_LONG XX[MD5_LBLOCK]; # define X(i) XX[i] #endif A=c->A; B=c->B; C=c->C; D=c->D; for (;num--;) { HOST_c2l(data,l); X( 0)=l; HOST_c2l(data,l); X( 1)=l; /* Round 0 */ R0(A,B,C,D,X( 0), 7,0xd76aa478L); HOST_c2l(data,l); X( 2)=l; R0(D,A,B,C,X( 1),12,0xe8c7b756L); HOST_c2l(data,l); X( 3)=l; R0(C,D,A,B,X( 2),17,0x242070dbL); HOST_c2l(data,l); X( 4)=l; R0(B,C,D,A,X( 3),22,0xc1bdceeeL); HOST_c2l(data,l); X( 5)=l; R0(A,B,C,D,X( 4), 7,0xf57c0fafL); HOST_c2l(data,l); X( 6)=l; R0(D,A,B,C,X( 5),12,0x4787c62aL); HOST_c2l(data,l); X( 7)=l; R0(C,D,A,B,X( 6),17,0xa8304613L); HOST_c2l(data,l); X( 8)=l; R0(B,C,D,A,X( 7),22,0xfd469501L); HOST_c2l(data,l); X( 9)=l; R0(A,B,C,D,X( 8), 7,0x698098d8L); HOST_c2l(data,l); X(10)=l; R0(D,A,B,C,X( 9),12,0x8b44f7afL); HOST_c2l(data,l); X(11)=l; R0(C,D,A,B,X(10),17,0xffff5bb1L); HOST_c2l(data,l); X(12)=l; R0(B,C,D,A,X(11),22,0x895cd7beL); HOST_c2l(data,l); X(13)=l; R0(A,B,C,D,X(12), 7,0x6b901122L); HOST_c2l(data,l); X(14)=l; R0(D,A,B,C,X(13),12,0xfd987193L); HOST_c2l(data,l); X(15)=l; R0(C,D,A,B,X(14),17,0xa679438eL); R0(B,C,D,A,X(15),22,0x49b40821L); /* Round 1 */ R1(A,B,C,D,X( 1), 5,0xf61e2562L); R1(D,A,B,C,X( 6), 9,0xc040b340L); R1(C,D,A,B,X(11),14,0x265e5a51L); R1(B,C,D,A,X( 0),20,0xe9b6c7aaL); R1(A,B,C,D,X( 5), 5,0xd62f105dL); R1(D,A,B,C,X(10), 9,0x02441453L); R1(C,D,A,B,X(15),14,0xd8a1e681L); R1(B,C,D,A,X( 4),20,0xe7d3fbc8L); R1(A,B,C,D,X( 9), 5,0x21e1cde6L); R1(D,A,B,C,X(14), 9,0xc33707d6L); R1(C,D,A,B,X( 3),14,0xf4d50d87L); R1(B,C,D,A,X( 8),20,0x455a14edL); R1(A,B,C,D,X(13), 5,0xa9e3e905L); R1(D,A,B,C,X( 2), 9,0xfcefa3f8L); R1(C,D,A,B,X( 7),14,0x676f02d9L); R1(B,C,D,A,X(12),20,0x8d2a4c8aL); /* Round 2 */ R2(A,B,C,D,X( 5), 4,0xfffa3942L); R2(D,A,B,C,X( 8),11,0x8771f681L); R2(C,D,A,B,X(11),16,0x6d9d6122L); R2(B,C,D,A,X(14),23,0xfde5380cL); R2(A,B,C,D,X( 1), 4,0xa4beea44L); R2(D,A,B,C,X( 4),11,0x4bdecfa9L); R2(C,D,A,B,X( 7),16,0xf6bb4b60L); R2(B,C,D,A,X(10),23,0xbebfbc70L); R2(A,B,C,D,X(13), 4,0x289b7ec6L); R2(D,A,B,C,X( 0),11,0xeaa127faL); R2(C,D,A,B,X( 3),16,0xd4ef3085L); R2(B,C,D,A,X( 6),23,0x04881d05L); R2(A,B,C,D,X( 9), 4,0xd9d4d039L); R2(D,A,B,C,X(12),11,0xe6db99e5L); R2(C,D,A,B,X(15),16,0x1fa27cf8L); R2(B,C,D,A,X( 2),23,0xc4ac5665L); /* Round 3 */ R3(A,B,C,D,X( 0), 6,0xf4292244L); R3(D,A,B,C,X( 7),10,0x432aff97L); R3(C,D,A,B,X(14),15,0xab9423a7L); R3(B,C,D,A,X( 5),21,0xfc93a039L); R3(A,B,C,D,X(12), 6,0x655b59c3L); R3(D,A,B,C,X( 3),10,0x8f0ccc92L); R3(C,D,A,B,X(10),15,0xffeff47dL); R3(B,C,D,A,X( 1),21,0x85845dd1L); R3(A,B,C,D,X( 8), 6,0x6fa87e4fL); R3(D,A,B,C,X(15),10,0xfe2ce6e0L); R3(C,D,A,B,X( 6),15,0xa3014314L); R3(B,C,D,A,X(13),21,0x4e0811a1L); R3(A,B,C,D,X( 4), 6,0xf7537e82L); R3(D,A,B,C,X(11),10,0xbd3af235L); R3(C,D,A,B,X( 2),15,0x2ad7d2bbL); R3(B,C,D,A,X( 9),21,0xeb86d391L); A = c->A += A; B = c->B += B; C = c->C += C; D = c->D += D; } }
{ .name = "procctl", .ret_type = 1, .nargs = 4, .args = { { Idtype, 0 }, { Int, 1 }, { Procctl, 2 }, { Ptr, 3 } } }, { .name = 0 }, }; /* Xlat idea taken from strace */ struct xlat { int val; const char *str; }; #define X(a) { a, #a }, #define XEND { 0, NULL } static struct xlat kevent_filters[] = { X(EVFILT_READ) X(EVFILT_WRITE) X(EVFILT_AIO) X(EVFILT_VNODE) X(EVFILT_PROC) X(EVFILT_SIGNAL) X(EVFILT_TIMER) X(EVFILT_FS) X(EVFILT_READ) XEND }; static struct xlat kevent_flags[] = { X(EV_ADD) X(EV_DELETE) X(EV_ENABLE) X(EV_DISABLE) X(EV_ONESHOT) X(EV_CLEAR) X(EV_FLAG1) X(EV_ERROR) X(EV_EOF) XEND }; static struct xlat poll_flags[] = { X(POLLSTANDARD) X(POLLIN) X(POLLPRI) X(POLLOUT) X(POLLERR) X(POLLHUP) X(POLLNVAL) X(POLLRDNORM) X(POLLRDBAND) X(POLLWRBAND) X(POLLINIGNEOF) XEND };
// CHECK-DAG: "\01?fooX@@YA?AVX@@XZ" // X64-DAG: "\01?fooX@@YA?AVX@@XZ" X fooX() { return X(); }
X(plan) X(plan_dft_c2r_1d)(int n, C *in, R *out, unsigned flags) { return X(plan_dft_c2r)(1, &n, in, out, flags); }
extern "C" void MCLDInitializeX86LDTarget() { // Register createTargetMachine function pointer to mcld::Target mcld::RegisterTargetMachine<mcld::X86TargetMachine> X(mcld::TheX86_32Target); mcld::RegisterTargetMachine<mcld::X86TargetMachine> Y(mcld::TheX86_64Target); }
void X(codelet_hc2cfdft_20) (planner *p) { X(khc2c_register) (p, hc2cfdft_20, &desc, HC2C_VIA_DFT); }
static plan *mkplan(const solver *ego_, const problem *p_, planner *plnr) { const S *ego = (const S *) ego_; const problem_mpi_rdft *p; P *pln; plan *cld1 = 0, *cldt = 0, *cld2 = 0; R *I, *O, *I2; tensor *sz; int i, my_pe, n_pes; INT nrest; static const plan_adt padt = { XM(rdft_solve), awake, print, destroy }; UNUSED(ego); if (!applicable(ego, p_, plnr)) return (plan *) 0; p = (const problem_mpi_rdft *) p_; I2 = I = p->I; O = p->O; if (ego->preserve_input || NO_DESTROY_INPUTP(plnr)) I = O; MPI_Comm_rank(p->comm, &my_pe); MPI_Comm_size(p->comm, &n_pes); sz = X(mktensor)(p->sz->rnk - 1); /* tensor of last rnk-1 dimensions */ i = p->sz->rnk - 2; A(i >= 0); sz->dims[i].n = p->sz->dims[i+1].n; sz->dims[i].is = sz->dims[i].os = p->vn; for (--i; i >= 0; --i) { sz->dims[i].n = p->sz->dims[i+1].n; sz->dims[i].is = sz->dims[i].os = sz->dims[i+1].n * sz->dims[i+1].is; } nrest = 1; for (i = 1; i < sz->rnk; ++i) nrest *= sz->dims[i].n; { INT is = sz->dims[0].n * sz->dims[0].is; INT b = XM(block)(p->sz->dims[0].n, p->sz->dims[0].b[IB], my_pe); cld1 = X(mkplan_d)(plnr, X(mkproblem_rdft_d)(sz, X(mktensor_2d)(b, is, is, p->vn, 1, 1), I2, I, p->kind + 1)); if (XM(any_true)(!cld1, p->comm)) goto nada; } nrest *= p->vn; cldt = X(mkplan_d)(plnr, XM(mkproblem_transpose)( p->sz->dims[0].n, p->sz->dims[1].n, nrest, I, O, p->sz->dims[0].b[IB], p->sz->dims[1].b[OB], p->comm, 0)); if (XM(any_true)(!cldt, p->comm)) goto nada; { INT is = p->sz->dims[0].n * nrest; INT b = XM(block)(p->sz->dims[1].n, p->sz->dims[1].b[OB], my_pe); cld2 = X(mkplan_d)(plnr, X(mkproblem_rdft_1_d)(X(mktensor_1d)( p->sz->dims[0].n, nrest, nrest), X(mktensor_2d)(b, is, is, nrest, 1, 1), O, O, p->kind[0])); if (XM(any_true)(!cld2, p->comm)) goto nada; } pln = MKPLAN_MPI_RDFT(P, &padt, apply); pln->cld1 = cld1; pln->cldt = cldt; pln->cld2 = cld2; pln->preserve_input = ego->preserve_input ? 2 : NO_DESTROY_INPUTP(plnr); X(ops_add)(&cld1->ops, &cld2->ops, &pln->super.super.ops); X(ops_add2)(&cldt->ops, &pln->super.super.ops); return &(pln->super.super); nada: X(plan_destroy_internal)(cld2); X(plan_destroy_internal)(cldt); X(plan_destroy_internal)(cld1); return (plan *) 0; }
static printer *mkprinter_file(FILE *f) { P_file *p = (P_file *) X(mkprinter)(sizeof(P_file), putchr_file, 0); p->f = f; return &p->super; }
X f() { return X(); } // Wynik zwracany przez wartosc
void X(codelet_t2_10) (planner *p) { X(kdft_dit_register) (p, t2_10, &desc); }
char Z[82][82],A,B,f,g=26;z(q){return atoi(q);}m(d,l){return Z[ B + X ( f + 3) * d+l *X(f+ 2 )][ A+X ( f ) * d + l* X ( f + 3 ) ] ;}int
void X(codelet_hb_10) (planner *p) { X(khc2hc_register) (p, hb_10, &desc); }
void X(codelet_m2bv_32) (planner *p) { X(kdft_register) (p, m2bv_32, &desc); }
static const char* iocode2str(DWORD ioc) { switch (ioc) { #define X(x) case (x): return #x X(IOCTL_SERIAL_CLEAR_STATS); X(IOCTL_SERIAL_CLR_DTR); X(IOCTL_SERIAL_CLR_RTS); X(IOCTL_SERIAL_CONFIG_SIZE); X(IOCTL_SERIAL_GET_BAUD_RATE); X(IOCTL_SERIAL_GET_CHARS); X(IOCTL_SERIAL_GET_COMMSTATUS); X(IOCTL_SERIAL_GET_DTRRTS); X(IOCTL_SERIAL_GET_HANDFLOW); X(IOCTL_SERIAL_GET_LINE_CONTROL); X(IOCTL_SERIAL_GET_MODEM_CONTROL); X(IOCTL_SERIAL_GET_MODEMSTATUS); X(IOCTL_SERIAL_GET_PROPERTIES); X(IOCTL_SERIAL_GET_STATS); X(IOCTL_SERIAL_GET_TIMEOUTS); X(IOCTL_SERIAL_GET_WAIT_MASK); X(IOCTL_SERIAL_IMMEDIATE_CHAR); X(IOCTL_SERIAL_LSRMST_INSERT); X(IOCTL_SERIAL_PURGE); X(IOCTL_SERIAL_RESET_DEVICE); X(IOCTL_SERIAL_SET_BAUD_RATE); X(IOCTL_SERIAL_SET_BREAK_ON); X(IOCTL_SERIAL_SET_BREAK_OFF); X(IOCTL_SERIAL_SET_CHARS); X(IOCTL_SERIAL_SET_DTR); X(IOCTL_SERIAL_SET_FIFO_CONTROL); X(IOCTL_SERIAL_SET_HANDFLOW); X(IOCTL_SERIAL_SET_LINE_CONTROL); X(IOCTL_SERIAL_SET_MODEM_CONTROL); X(IOCTL_SERIAL_SET_QUEUE_SIZE); X(IOCTL_SERIAL_SET_RTS); X(IOCTL_SERIAL_SET_TIMEOUTS); X(IOCTL_SERIAL_SET_WAIT_MASK); X(IOCTL_SERIAL_SET_XOFF); X(IOCTL_SERIAL_SET_XON); X(IOCTL_SERIAL_WAIT_ON_MASK); X(IOCTL_SERIAL_XOFF_COUNTER); #undef X default: { static char tmp[32]; sprintf(tmp, "IOCTL_SERIAL_%d\n", ioc); return tmp; } } }
void X(kdft_register)(planner *p, kdft codelet, const kdft_desc *desc) { REGISTER_SOLVER(p, X(mksolver_dft_direct)(codelet, desc)); REGISTER_SOLVER(p, X(mksolver_dft_directbuf)(codelet, desc)); }
template<typename Scalar> void sparse_llt(int rows, int cols) { double density = std::max(8./(rows*cols), 0.01); typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix; typedef Matrix<Scalar,Dynamic,1> DenseVector; // TODO fix the issue with complex (see SparseLLT::solveInPlace) SparseMatrix<Scalar> m2(rows, cols); DenseMatrix refMat2(rows, cols); DenseVector b = DenseVector::Random(cols); DenseVector ref_x(cols), x(cols); DenseMatrix B = DenseMatrix::Random(rows,cols); DenseMatrix ref_X(rows,cols), X(rows,cols); initSparse<Scalar>(density, refMat2, m2, ForceNonZeroDiag|MakeLowerTriangular, 0, 0); for(int i=0; i<rows; ++i) m2.coeffRef(i,i) = refMat2(i,i) = internal::abs(internal::real(refMat2(i,i))); ref_x = refMat2.template selfadjointView<Lower>().llt().solve(b); if (!NumTraits<Scalar>::IsComplex) { x = b; SparseLLT<SparseMatrix<Scalar> > (m2).solveInPlace(x); VERIFY(ref_x.isApprox(x,test_precision<Scalar>()) && "LLT: default"); } #ifdef EIGEN_CHOLMOD_SUPPORT // legacy API { // Cholmod, as configured in CholmodSupport.h, only supports self-adjoint matrices SparseMatrix<Scalar> m3 = m2.adjoint()*m2; DenseMatrix refMat3 = refMat2.adjoint()*refMat2; ref_x = refMat3.template selfadjointView<Lower>().llt().solve(b); x = b; SparseLLT<SparseMatrix<Scalar>, Cholmod>(m3).solveInPlace(x); VERIFY((m3*x).isApprox(b,test_precision<Scalar>()) && "LLT legacy: cholmod solveInPlace"); x = SparseLLT<SparseMatrix<Scalar>, Cholmod>(m3).solve(b); VERIFY(ref_x.isApprox(x,test_precision<Scalar>()) && "LLT legacy: cholmod solve"); } // new API { // Cholmod, as configured in CholmodSupport.h, only supports self-adjoint matrices SparseMatrix<Scalar> m3 = m2 * m2.adjoint(), m3_lo(rows,rows), m3_up(rows,rows); DenseMatrix refMat3 = refMat2 * refMat2.adjoint(); m3_lo.template selfadjointView<Lower>().rankUpdate(m2,0); m3_up.template selfadjointView<Upper>().rankUpdate(m2,0); // with a single vector as the rhs ref_x = refMat3.template selfadjointView<Lower>().llt().solve(b); x = CholmodDecomposition<SparseMatrix<Scalar>, Lower>(m3).solve(b); VERIFY(ref_x.isApprox(x,test_precision<Scalar>()) && "LLT: cholmod solve, single dense rhs"); x = CholmodDecomposition<SparseMatrix<Scalar>, Upper>(m3).solve(b); VERIFY(ref_x.isApprox(x,test_precision<Scalar>()) && "LLT: cholmod solve, single dense rhs"); x = CholmodDecomposition<SparseMatrix<Scalar>, Lower>(m3_lo).solve(b); VERIFY(ref_x.isApprox(x,test_precision<Scalar>()) && "LLT: cholmod solve, single dense rhs"); x = CholmodDecomposition<SparseMatrix<Scalar>, Upper>(m3_up).solve(b); VERIFY(ref_x.isApprox(x,test_precision<Scalar>()) && "LLT: cholmod solve, single dense rhs"); // with multiple rhs ref_X = refMat3.template selfadjointView<Lower>().llt().solve(B); #ifndef EIGEN_DEFAULT_TO_ROW_MAJOR // TODO make sure the API is properly documented about this fact X = CholmodDecomposition<SparseMatrix<Scalar>, Lower>(m3).solve(B); VERIFY(ref_X.isApprox(X,test_precision<Scalar>()) && "LLT: cholmod solve, multiple dense rhs"); X = CholmodDecomposition<SparseMatrix<Scalar>, Upper>(m3).solve(B); VERIFY(ref_X.isApprox(X,test_precision<Scalar>()) && "LLT: cholmod solve, multiple dense rhs"); #endif // with a sparse rhs SparseMatrix<Scalar> spB(rows,cols), spX(rows,cols); B.diagonal().array() += 1; spB = B.sparseView(0.5,1); ref_X = refMat3.template selfadjointView<Lower>().llt().solve(DenseMatrix(spB)); spX = CholmodDecomposition<SparseMatrix<Scalar>, Lower>(m3).solve(spB); VERIFY(ref_X.isApprox(spX.toDense(),test_precision<Scalar>()) && "LLT: cholmod solve, multiple sparse rhs"); spX = CholmodDecomposition<SparseMatrix<Scalar>, Upper>(m3).solve(spB); VERIFY(ref_X.isApprox(spX.toDense(),test_precision<Scalar>()) && "LLT: cholmod solve, multiple sparse rhs"); } #endif }
void md5_block_data_order (MD5_CTX *c, const void *data_, size_t num) { const unsigned char *data=data_; register unsigned MD32_REG_T A,B,C,D,l; #ifndef MD32_XARRAY /* See comment in crypto/sha/sha_locl.h for details. */ unsigned MD32_REG_T XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7, XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15; # define X(i) XX##i #else MD5_LONG XX[MD5_LBLOCK]; # define X(i) XX[i] #endif A=c->A; B=c->B; C=c->C; D=c->D; for (;num--;) { HOST_c2l(data,l); X( 0)=l; HOST_c2l(data,l); X( 1)=l; /* Round 0 */ R0(A,B,C,D,X( 0), 7,0xd76aa478L); HOST_c2l(data,l); X( 2)=l; R0(D,A,B,C,X( 1),12,0xe8c7b756L); HOST_c2l(data,l); X( 3)=l; R0(C,D,A,B,X( 2),17,0x242070dbL); HOST_c2l(data,l); X( 4)=l; R0(B,C,D,A,X( 3),22,0xc1bdceeeL); HOST_c2l(data,l); X( 5)=l; R0(A,B,C,D,X( 4), 7,0xf57c0fafL); HOST_c2l(data,l); X( 6)=l; R0(D,A,B,C,X( 5),12,0x4787c62aL); HOST_c2l(data,l); X( 7)=l; R0(C,D,A,B,X( 6),17,0xa8304613L); HOST_c2l(data,l); X( 8)=l; R0(B,C,D,A,X( 7),22,0xfd469501L); HOST_c2l(data,l); X( 9)=l; R0(A,B,C,D,X( 8), 7,0x698098d8L); HOST_c2l(data,l); X(10)=l; R0(D,A,B,C,X( 9),12,0x8b44f7afL); HOST_c2l(data,l); X(11)=l; R0(C,D,A,B,X(10),17,0xffff5bb1L); HOST_c2l(data,l); X(12)=l; R0(B,C,D,A,X(11),22,0x895cd7beL); HOST_c2l(data,l); X(13)=l; R0(A,B,C,D,X(12), 7,0x6b901122L); HOST_c2l(data,l); X(14)=l; R0(D,A,B,C,X(13),12,0xfd987193L); HOST_c2l(data,l); X(15)=l; R0(C,D,A,B,X(14),17,0xa679438eL); R0(B,C,D,A,X(15),22,0x49b40821L); /* Round 1 */ R1(A,B,C,D,X( 1), 5,0xf61e2562L); R1(D,A,B,C,X( 6), 9,0xc040b340L); R1(C,D,A,B,X(11),14,0x265e5a51L); R1(B,C,D,A,X( 0),20,0xe9b6c7aaL); R1(A,B,C,D,X( 5), 5,0xd62f105dL); R1(D,A,B,C,X(10), 9,0x02441453L); R1(C,D,A,B,X(15),14,0xd8a1e681L); R1(B,C,D,A,X( 4),20,0xe7d3fbc8L); R1(A,B,C,D,X( 9), 5,0x21e1cde6L); R1(D,A,B,C,X(14), 9,0xc33707d6L); R1(C,D,A,B,X( 3),14,0xf4d50d87L); R1(B,C,D,A,X( 8),20,0x455a14edL); R1(A,B,C,D,X(13), 5,0xa9e3e905L); R1(D,A,B,C,X( 2), 9,0xfcefa3f8L); R1(C,D,A,B,X( 7),14,0x676f02d9L); R1(B,C,D,A,X(12),20,0x8d2a4c8aL); /* Round 2 */ R2(A,B,C,D,X( 5), 4,0xfffa3942L); R2(D,A,B,C,X( 8),11,0x8771f681L); R2(C,D,A,B,X(11),16,0x6d9d6122L); R2(B,C,D,A,X(14),23,0xfde5380cL); R2(A,B,C,D,X( 1), 4,0xa4beea44L); R2(D,A,B,C,X( 4),11,0x4bdecfa9L); R2(C,D,A,B,X( 7),16,0xf6bb4b60L); R2(B,C,D,A,X(10),23,0xbebfbc70L); R2(A,B,C,D,X(13), 4,0x289b7ec6L); R2(D,A,B,C,X( 0),11,0xeaa127faL); R2(C,D,A,B,X( 3),16,0xd4ef3085L); R2(B,C,D,A,X( 6),23,0x04881d05L); R2(A,B,C,D,X( 9), 4,0xd9d4d039L); R2(D,A,B,C,X(12),11,0xe6db99e5L); R2(C,D,A,B,X(15),16,0x1fa27cf8L); R2(B,C,D,A,X( 2),23,0xc4ac5665L); /* Round 3 */ R3(A,B,C,D,X( 0), 6,0xf4292244L); R3(D,A,B,C,X( 7),10,0x432aff97L); R3(C,D,A,B,X(14),15,0xab9423a7L); R3(B,C,D,A,X( 5),21,0xfc93a039L); R3(A,B,C,D,X(12), 6,0x655b59c3L); R3(D,A,B,C,X( 3),10,0x8f0ccc92L); R3(C,D,A,B,X(10),15,0xffeff47dL); R3(B,C,D,A,X( 1),21,0x85845dd1L); R3(A,B,C,D,X( 8), 6,0x6fa87e4fL); R3(D,A,B,C,X(15),10,0xfe2ce6e0L); R3(C,D,A,B,X( 6),15,0xa3014314L); R3(B,C,D,A,X(13),21,0x4e0811a1L); R3(A,B,C,D,X( 4), 6,0xf7537e82L); R3(D,A,B,C,X(11),10,0xbd3af235L); R3(C,D,A,B,X( 2),15,0x2ad7d2bbL); R3(B,C,D,A,X( 9),21,0xeb86d391L); A = c->A += A; B = c->B += B; C = c->C += C; D = c->D += D; } }
void X(codelet_hf2_5) (planner *p) { X(khc2hc_register) (p, hf2_5, &desc); }
void testReferenceMember() { int *p = 0; RefWrapper X(p); // expected-warning@61 {{Dereference of null pointer}} }
void test(std::ostream &outStream = std::cout ) const { size_t size = 1; std::vector<Real> X(size,4.*(Real)rand()/(Real)RAND_MAX - 2.); std::vector<int> T(size,0); Distribution<Real>::test(X,T,outStream); }
void testReferenceMember2() { int *p = 0; // FIXME: We should warn here, since we're creating the reference here. RefWrapper X(*p); // expected-warning@62 {{Dereference of null pointer}} }
X f() { return X(); } // Return by value
void X(codelet_hf_8) (planner *p) { X(khc2hc_dit_register) (p, hf_8, &desc); }
void X(codelet_r2cb_8) (planner *p) { X(kr2c_register) (p, r2cb_8, &desc); }
void X(codelet_n1bv_20) (planner *p) { X(kdft_register) (p, n1bv_20, &desc); }