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);
			}
		}
	}
}
示例#2
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());
}
示例#3
0
/* 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_ */
示例#4
0
文件: t1sv_16.c 项目: Aegisub/fftw3
void XSIMD(codelet_t1sv_16) (planner *p) {
     X(kdft_dit_register) (p, t1sv_16, &desc);
}
示例#5
0
文件: t1_3.c 项目: 8cH9azbsFifZ/wspr
void X(codelet_t1_3) (planner *p) {
     X(kdft_dit_register) (p, t1_3, &desc);
}
示例#6
0
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;
		}
	}
示例#7
0
	{ .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
};
示例#8
0
// CHECK-DAG: "\01?fooX@@YA?AVX@@XZ"
// X64-DAG:   "\01?fooX@@YA?AVX@@XZ"
X fooX() { return X(); }
示例#9
0
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);
}
示例#11
0
void X(codelet_hc2cfdft_20) (planner *p) {
     X(khc2c_register) (p, hc2cfdft_20, &desc, HC2C_VIA_DFT);
}
示例#12
0
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;
}
示例#13
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;
}
示例#14
0
X f() { return X(); } // Wynik zwracany przez wartosc
示例#15
0
void X(codelet_t2_10) (planner *p) {
     X(kdft_dit_register) (p, t2_10, &desc);
}
示例#16
0
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);
}
示例#18
0
void X(codelet_m2bv_32) (planner *p) {
     X(kdft_register) (p, m2bv_32, &desc);
}
示例#19
0
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; }
    }
}
示例#20
0
文件: kdft.c 项目: 8cH9azbsFifZ/wspr
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));
}
示例#21
0
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

}
示例#22
0
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;
		}
	}
示例#23
0
文件: hf2_5.c 项目: 8cH9azbsFifZ/wspr
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}}
}
示例#27
0
X f() { return X(); } // Return by value
示例#28
0
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);
}
示例#30
0
文件: n1bv_20.c 项目: bambang/vsipl
void X(codelet_n1bv_20) (planner *p) {
     X(kdft_register) (p, n1bv_20, &desc);
}