Exemplo n.º 1
0
   int ARLambda::factorize( const Matrix<double>& Q, 
                            Matrix<double>& L, 
                            Vector<double>& D)
   {
      // TODO: CHECK UNEXPECTED INPUT
      // L:nxn Z:nxn 0<=(i,j)<n

      const int n = static_cast<int>(Q.rows());

      Matrix<double> QC(Q);
      L.resize(n, n, 0.0);
      D.resize(n, 0.0);

      for(int i = n-1; i >= 0; i--) 
      {
         D(i) = QC(i,i);
         if( D(i) <= 0.0 ) return -1;
         double temp = std::sqrt(D(i));
         for(int j=0; j<=i; j++) L(i,j) = QC(i,j)/temp;
         for(int j=0; j<=i-1; j++) 
         {
            for(int k=0; k<=j; k++) QC(j,k) -= L(i,k) * L(i,j);
         }
         for(int j=0; j<=i; j++) L(i,j) /= L(i,i);
      }

      return 0;

   }  // End of method 'ARLambda::factorize()'
Exemplo n.º 2
0
static int
Qs(q_g_mul_p_)(lua_State *L)
{
    mClifford *m = qlua_checkClifford(L, 1);
    Qs(mSeqDirProp) *f = Qs(qlua_checkSeqDirProp)(L, 2, -1);
    Qs(mSeqDirProp) *mf = Qs(qlua_newSeqDirProp)(L, QC(f));
    Qs(mSeqDirProp) *r = Qs(qlua_newZeroSeqDirProp)(L, QC(f));
    int i;
    
    for (i = 0; i < 16; i++) {
        switch (m->g[i].t) {
        case qG_z: continue;
        case qG_p:
            Qx(QLA_D,_P_eq_gamma_times_P)(QNC(QC(f)) mf->ptr, f->ptr, i);
            Qx(QLA_D,_P_peq_P)(QNC(QC(f)) r->ptr, mf->ptr);
            break;
        case qG_m:
            Qx(QLA_D,_P_eq_gamma_times_P)(QNC(QC(f)) mf->ptr, f->ptr, i);
            Qx(QLA_D,_P_meq_P)(QNC(QC(f)) r->ptr, mf->ptr);
            break;
        case qG_r:
            Qx(QLA_D,_P_eq_gamma_times_P)(QNC(QC(f)) mf->ptr, f->ptr, i);
            Qx(QLA_D,_P_peq_r_times_P)(QNC(QC(f)) r->ptr, &m->g[i].r, mf->ptr);
            break;
        case qG_c:
            Qx(QLA_D,_P_eq_gamma_times_P)(QNC(QC(f)) mf->ptr, f->ptr, i);
            Qx(QLA_D,_P_peq_c_times_P)(QNC(QC(f)) r->ptr, &m->g[i].c, mf->ptr);
            break;
        }
    }
    return 1;
}
Exemplo n.º 3
0
static int
Qs(q_g_mul_D_)(lua_State *L)
{
    mClifford *m = qlua_checkClifford(L, 1);
    Qs(mLatDirFerm) *f = Qs(qlua_checkLatDirFerm)(L, 2, NULL, -1);
    mLattice *S = qlua_ObjLattice(L, 2);
    int Sidx = lua_gettop(L);
    Qs(mLatDirFerm) *mf = Qs(qlua_newLatDirFerm)(L, Sidx, QC(f));
    Qs(mLatDirFerm) *r = Qs(qlua_newZeroLatDirFerm)(L, Sidx, QC(f));
    int i;

    CALL_QDP(L);
    for (i = 0; i < 16; i++) {
        switch (m->g[i].t) {
        case qG_z: continue;
        case qG_p:
            Qx(QDP_D,_D_eq_gamma_times_D)(mf->ptr, f->ptr, i, *S->qss);
            Qx(QDP_D,_D_peq_D)(r->ptr, mf->ptr, *S->qss);
            break;
        case qG_m:
            Qx(QDP_D,_D_eq_gamma_times_D)(mf->ptr, f->ptr, i, *S->qss);
            Qx(QDP_D,_D_meq_D)(r->ptr, mf->ptr, *S->qss);
            break;
        case qG_r:
            Qx(QDP_D,_D_eq_gamma_times_D)(mf->ptr, f->ptr, i, *S->qss);
            Qx(QDP_D,_D_peq_r_times_D)(r->ptr, &m->g[i].r, mf->ptr, *S->qss);
            break;
        case qG_c:
            Qx(QDP_D,_D_eq_gamma_times_D)(mf->ptr, f->ptr, i, *S->qss);
            Qx(QDP_D,_D_peq_c_times_D)(r->ptr, &m->g[i].c, mf->ptr, *S->qss);
            break;
        }
    }
    return 1;
}
Exemplo n.º 4
0
static QualType getTypeWithAttribute(ASTContext &C, QualType T, Qualifiers::AS AS) {
  auto Split = T.split();
  if(Split.second.hasAttributeSpec(AS))
    return T;
  QualifierCollector QC(Split.second);
  QC.addAttributeSpecs(AS);
  return C.getTypeWithQualifers(T, QC);
}
Exemplo n.º 5
0
static int
Qs(q_M_fmt)(lua_State *L)
{
    char fmt[72];
    Qs(mLatColMat) *b = Qs(qlua_checkLatColMat)(L, 1, NULL, -1);

    sprintf(fmt, "QDP:ColorMatrix%d(%p)", QC(b), b->ptr);
    lua_pushstring(L, fmt);

    return 1;
}
void	xrMU_Model::export_geometry		()
{
    // Declarator
    VDeclarator			D;
    D.set				(decl);

    // RT-check, BOX, low-point, frac-size
    Fbox			BB;
    BB.invalidate	();
    for (v_vertices_it vit=m_vertices.begin(); vit!=m_vertices.end(); vit++)
        BB.modify	((*vit)->P);

    Fvector			frac_low;
    float			frac_Ysize;
    BB.getcenter	(frac_low);
    frac_low.y	= BB.min.y;
    frac_Ysize		= BB.max.y - BB.min.y;

    // Begin building
    for (v_subdivs_it it=m_subdivs.begin(); it!=m_subdivs.end(); it++)
    {
        // Vertices
        {
            g_VB.Begin		(D);

            vecOGF_V&	verts	= it->ogf->vertices;
            for (u32 v_it=0; v_it<verts.size(); v_it++)
            {
                OGF_Vertex&		oV	= verts[v_it];

                // Position
                g_VB.Add	(&oV.P,3*sizeof(float));

                // Normal
                {
                    base_color_c	oV_c;
                    oV.Color._get(oV_c);
                    Fvector N	= oV.N;
                    N.add		(1.f);
                    N.mul		(.5f*255.f);
                    s32 nx		= iFloor(N.x);
                    clamp(nx,0,255);
                    s32 ny		= iFloor(N.y);
                    clamp(ny,0,255);
                    s32 nz		= iFloor(N.z);
                    clamp(nz,0,255);
                    s32 cc		= iFloor(oV_c.hemi*255.f);
                    clamp(cc,0,255);
                    u32	uN		= color_rgba(nx,ny,nz,cc);
                    g_VB.Add	(&uN,4);
                }

                // Tangent
                {
                    u32	uT		= color_rgba(oV.T.x,oV.T.y,oV.T.z,0);
                    g_VB.Add	(&uT,4);
                }

                // Binormal
                {
                    u32	uB		= color_rgba(oV.B.x,oV.B.y,oV.B.z,0);
                    g_VB.Add	(&uB,4);
                }

                // TC
                s16	tu,tv,frac,dummy;
                tu			= QC(oV.UV.begin()->x);
                tv			= QC(oV.UV.begin()->y);
                g_VB.Add	(&tu,2);
                g_VB.Add	(&tv,2);

                // frac
                float	f1	= (oV.P.y - frac_low.y)		/frac_Ysize;
                float	f2	= oV.P.distance_to(frac_low)/frac_Ysize;
                frac		= QC((f1+f2)/2.f);
                dummy		= 0;
                g_VB.Add	(&frac,	2);
                g_VB.Add	(&dummy,2);
            }

            g_VB.End		(&it->vb_id,&it->vb_start);
        }

        // Indices
        g_IB.Register	(LPWORD(&*it->ogf->faces.begin()),LPWORD(&*it->ogf->faces.end()),&it->ib_id,&it->ib_start);

        // SW
        if (it->ogf->progressive_test())
            g_SWI.Register	(&it->sw_id,&it->ogf->m_SWI);
    }
}
Exemplo n.º 7
0
void CDetailManager::hw_Load_Geom()
{
	// Analyze batch-size
	hw_BatchSize	= (u32(HW.Caps.geometry.dwRegisters)-c_hdr)/c_size;
	clamp			(hw_BatchSize,(u32)0,(u32)64);
	Msg				("* [DETAILS] VertexConsts(%d), Batch(%d)",u32(HW.Caps.geometry.dwRegisters),hw_BatchSize);

	// Pre-process objects
	u32			dwVerts		= 0;
	u32			dwIndices	= 0;
	for (u32 o=0; o<objects.size(); o++)
	{
		const CDetail& D	=	*objects[o];
		dwVerts		+=	D.number_vertices*hw_BatchSize;
		dwIndices	+=	D.number_indices*hw_BatchSize;
	}
	u32			vSize		= sizeof(vertHW);
	Msg("* [DETAILS] %d v(%d), %d p",dwVerts,vSize,dwIndices/3);

#if !defined(USE_DX10) && !defined(USE_DX11)
	// Determine POOL & USAGE
	u32 dwUsage		=	D3DUSAGE_WRITEONLY;

	// Create VB/IB
	R_CHK			(HW.pDevice->CreateVertexBuffer	(dwVerts*vSize,dwUsage,0,D3DPOOL_MANAGED,&hw_VB,0));
	HW.stats_manager.increment_stats_vb				(hw_VB);
	R_CHK			(HW.pDevice->CreateIndexBuffer	(dwIndices*2,dwUsage,D3DFMT_INDEX16,D3DPOOL_MANAGED,&hw_IB,0));
	HW.stats_manager.increment_stats_ib				(hw_IB);

#endif	//	USE_DX10
	Msg("* [DETAILS] Batch(%d), VB(%dK), IB(%dK)",hw_BatchSize,(dwVerts*vSize)/1024, (dwIndices*2)/1024);

	// Fill VB
	{
		vertHW*			pV;
#if defined(USE_DX10) || defined(USE_DX11)
		vertHW*			pVOriginal;
		pVOriginal	=	xr_alloc<vertHW>(dwVerts);
		pV = pVOriginal;		
#else	//	USE_DX10
		R_CHK			(hw_VB->Lock(0,0,(void**)&pV,0));
#endif	//	USE_DX10
		for (o=0; o<objects.size(); o++)
		{
			const CDetail& D		=	*objects[o];
			for (u32 batch=0; batch<hw_BatchSize; batch++)
			{
				u32 mid	=	batch*c_size;
				for (u32 v=0; v<D.number_vertices; v++)
				{
					const Fvector&	vP = D.vertices[v].P;
					pV->x	=	vP.x;
					pV->y	=	vP.y;
					pV->z	=	vP.z;
					pV->u	=	QC(D.vertices[v].u);
					pV->v	=	QC(D.vertices[v].v);
					pV->t	=	QC(vP.y/(D.bv_bb.max.y-D.bv_bb.min.y));
					pV->mid	=	short(mid);
					pV++;
				}
			}
		}
#if defined(USE_DX10) || defined(USE_DX11)
		R_CHK(dx10BufferUtils::CreateVertexBuffer(&hw_VB, pVOriginal, dwVerts*vSize));
		HW.stats_manager.increment_stats_vb		( hw_VB);
		xr_free(pVOriginal);
#else	//	USE_DX10
		R_CHK			(hw_VB->Unlock());
#endif	//	USE_DX10
	}

	// Fill IB
	{
		u16*			pI;
#if defined(USE_DX10) || defined(USE_DX11)
		u16*			pIOriginal;
		pIOriginal = xr_alloc<u16>(dwIndices);
		pI	= pIOriginal;
#else	//	USE_DX10
		R_CHK			(hw_IB->Lock(0,0,(void**)(&pI),0));
#endif	//	USE_DX10
		for (o=0; o<objects.size(); o++)
		{
			const CDetail& D		=	*objects[o];
			u16		offset	=	0;
			for (u32 batch=0; batch<hw_BatchSize; batch++)
			{
				for (u32 i=0; i<u32(D.number_indices); i++)
					*pI++	=	u16(u16(D.indices[i]) + u16(offset));
				offset		=	u16(offset+u16(D.number_vertices));
			}
		}
#if defined(USE_DX10) || defined(USE_DX11)
		R_CHK(dx10BufferUtils::CreateIndexBuffer(&hw_IB, pIOriginal, dwIndices*2));
		HW.stats_manager.increment_stats_ib		(hw_IB);
		xr_free(pIOriginal);
#else	//	USE_DX10
		R_CHK			(hw_IB->Unlock());
#endif	//	USE_DX10
	}

	// Declare geometry
	hw_Geom.create		(dwDecl, hw_VB, hw_IB);
}
Exemplo n.º 8
0
void CDetailManager::hw_Load	()
{
	// Analyze batch-size
	hw_BatchSize	= (u32(HW.Caps.geometry.dwRegisters)-c_hdr)/c_size;
	clamp			(hw_BatchSize,(u32)0,(u32)64);
	Msg				("* [DETAILS] VertexConsts(%d), Batch(%d)",u32(HW.Caps.geometry.dwRegisters),hw_BatchSize);

	// Pre-process objects
	u32			dwVerts		= 0;
	u32			dwIndices	= 0;
	for (u32 o=0; o<objects.size(); o++)
	{
		CDetail& D	=	*objects[o];
		dwVerts		+=	D.number_vertices*hw_BatchSize;
		dwIndices	+=	D.number_indices*hw_BatchSize;
	}
	u32			vSize		= sizeof(vertHW);
	Msg("* [DETAILS] %d v(%d), %d p",dwVerts,vSize,dwIndices/3);

	// Determine POOL & USAGE
	u32 dwUsage		=	D3DUSAGE_WRITEONLY;

	// Create VB/IB
	R_CHK			(HW.pDevice->CreateVertexBuffer(dwVerts*vSize,dwUsage,0,D3DPOOL_MANAGED,&hw_VB,0));
	R_CHK			(HW.pDevice->CreateIndexBuffer(dwIndices*2,dwUsage,D3DFMT_INDEX16,D3DPOOL_MANAGED,&hw_IB,0));
	Msg("* [DETAILS] Batch(%d), VB(%dK), IB(%dK)",hw_BatchSize,(dwVerts*vSize)/1024, (dwIndices*2)/1024);

	// Fill VB
	{
		vertHW*			pV;
		R_CHK			(hw_VB->Lock(0,0,(void**)&pV,0));
		for (o=0; o<objects.size(); o++)
		{
			CDetail& D		=	*objects[o];
			for (u32 batch=0; batch<hw_BatchSize; batch++)
			{
				u32 mid	=	batch*c_size;
				for (u32 v=0; v<D.number_vertices; v++)
				{
					Fvector&	vP = D.vertices[v].P;
					pV->x	=	vP.x;
					pV->y	=	vP.y;
					pV->z	=	vP.z;
					pV->u	=	QC(D.vertices[v].u);
					pV->v	=	QC(D.vertices[v].v);
					pV->t	=	QC(vP.y/(D.bv_bb.max.y-D.bv_bb.min.y));
					pV->mid	=	short(mid);
					pV++;
				}
			}
		}
		R_CHK			(hw_VB->Unlock());
	}

	// Fill IB
	{
		u16*			pI;
		R_CHK			(hw_IB->Lock(0,0,(void**)(&pI),0));
		for (o=0; o<objects.size(); o++)
		{
			CDetail& D		=	*objects[o];
			u16		offset	=	0;
			for (u32 batch=0; batch<hw_BatchSize; batch++)
			{
				for (u32 i=0; i<u32(D.number_indices); i++)
					*pI++	=	u16(u16(D.indices[i]) + u16(offset));
				offset		=	u16(offset+u16(D.number_vertices));
			}
		}
		R_CHK			(hw_IB->Unlock());
	}

	// Create shader to access constant storage
	ref_shader		S;	S.create("details\\set");
	R_constant_table&	T0	= *(S->E[0]->passes[0]->constants);
	R_constant_table&	T1	= *(S->E[1]->passes[0]->constants);
	hwc_consts			= T0.get("consts");
	hwc_wave			= T0.get("wave");
	hwc_wind			= T0.get("dir2D");
	hwc_array			= T0.get("array");
	hwc_s_consts		= T1.get("consts");
	hwc_s_xform			= T1.get("xform");
	hwc_s_array			= T1.get("array");

	// Declare geometry
	hw_Geom.create		(dwDecl, hw_VB, hw_IB);
}