//----------------------------------------------------------------------------
// Extended interval division 'A / B' where 0 in 'B' is allowed.
//----------------------------------------------------------------------------
xinterval operator% ( const interval& A, const interval& B )
{
interval c;
xinterval Q;
if ( in(0.0, B) ) {
if ( in(0.0, A) ) {
Q.kind = Double; // Q = [-oo,+oo] = [-oo,0] v [0,+oo]
Q.sup = 0.0; //----------------------------------
Q.inf = 0.0;
}
else if ( B == 0.0 ) { // Q = [/]
Q.kind = PlusInfty; //--------
Q.inf = divd(Sup(A),Inf(B));
}
else if ( (Sup(A) < 0.0) && (Sup(B) == 0.0) ) { // Q = [Q.inf,+oo]
Q.kind = PlusInfty; //----------------
Q.inf = divd(Sup(A),Inf(B));
}
else if ( (Sup(A) < 0.0) && (Inf(B) < 0.0) && (Sup(B) > 0.0) ) {
Q.kind = Double; // Q = [-oo,Q.sup] v [Q.inf,+oo]
Q.sup = divu(Sup(A),Sup(B)); //------------------------------
Q.inf = divd(Sup(A),Inf(B));
}
else if ( (Sup(A) < 0.0) && (Inf(B) == 0.0) ) { // Q = [-oo,Q.sup]
Q.kind = MinusInfty; //----------------
Q.sup = divu(Sup(A),Sup(B));
}
else if ( (Inf(A) > 0.0) && (Sup(B) == 0.0) ) { // Q = [-oo,Q.sup]
Q.kind = MinusInfty; //----------------
Q.sup = divu(Inf(A),Inf(B));
}
else if ( (Inf(A) > 0.0) && (Inf(B) < 0.0) && (Sup(B) > 0.0) ) {
Q.kind = Double; // Q = [-oo,Q.sup] v [Q.inf,+oo]
Q.sup = divu(Inf(A),Inf(B)); //------------------------------
Q.inf = divd(Inf(A),Sup(B));
}
else { // if ( (Inf(A) > 0.0) && (Inf(B) == 0.0) )
Q.kind = PlusInfty; // Q = [Q.inf,+oo]
Q.inf = divd(Inf(A),Sup(B)); //----------------
}
} // in(0.0,B)
else { // !in(0.0,B)
c = A / B; // Q = [C.inf,C.sup]
Q.kind = Finite; //------------------
Q.inf = Inf(c);
Q.sup = Sup(c);
}
return Q;
} // operator%
void
divsir(int opnd1, int opnd2, struct mdsfu_register *result)
{
int sign, op1_sign;
/* check divisor for zero */
if (opnd2 == 0) {
overflow = true;
return;
}
/* get sign of result */
sign = opnd1 ^ opnd2;
/* get absolute value of operands */
if (opnd1 < 0) {
opnd1 = -opnd1;
op1_sign = true;
}
else op1_sign = false;
if (opnd2 < 0) opnd2 = -opnd2;
/* check for opnd2 = -2**31 */
if (opnd2 + opnd2 == 0) {
if (opnd1 == opnd2) {
result_hi = 0; /* remainder = 0 */
result_lo = 1;
}
else {
result_hi = opnd1; /* remainder = opnd1 */
result_lo = 0;
}
}
else {
/* do the divide */
divu(0,opnd1,opnd2,result);
/*
* check for overflow
*
* at this point, the only way we can get overflow
* is with opnd1 = -2**31 and opnd2 = -1
*/
if (sign>0 && result_lo<0) {
overflow = true;
return;
}
}
overflow = false;
/* return appropriately signed remainder and result */
if (op1_sign) result_hi = -result_hi;
if (sign<0) result_lo = -result_lo;
return;
}
void GodunovPhysics::artVisc(FArrayBox& a_F,
const FArrayBox& a_U,
const Real& a_artificialViscosity,
const Real& a_currentTime,
const int& a_dir,
const Box& a_box)
{
CH_assert(a_U.box().contains(a_box)); // a_box: valid cells
// Take the cell-centered box, a_box, and derive a face-centered box in
// direction a_dir.
// faceBox consists of all a_dir-faces of valid cells.
Box faceBox = a_box;
faceBox &= m_domain;
faceBox.surroundingNodes(a_dir);
CH_assert(a_F.box().contains(faceBox));
// Derive a cell-centered box where the primitive variables are needed.
// wBox consists of valid cells grown by 1, intersected with m_domain.
Box wBox = faceBox;
wBox.enclosedCells(a_dir);
wBox.grow(1);
wBox &= m_domain;
// Get the primitive variables from the conserved variables (as needed).
int numPrim = numPrimitives();
FArrayBox W(wBox, numPrim);
consToPrim(W, a_U, wBox); // W on valid cells + 1 layer of ghosts
// Compute the divergence of the velocity
FArrayBox divu(faceBox, 1);
Interval velInt = velocityInterval();
m_util.divVel(divu, W, velInt, a_dir, faceBox);
// If using fourth-order artificial viscosity, apply the nonlinear operator to
// divu.
if (m_useFourthOrderArtificialViscosity)
m_util.divVelHO(divu, W, a_dir, faceBox, this);
// Change fluxes due to artificial viscosity on the interior faces
m_util.artificialViscosity(a_F, a_U,
divu, a_artificialViscosity, a_dir, faceBox);
// Change fluxes due to artificial viscosity on the boundary faces
m_bc->artViscBC(a_F, a_U, divu, a_dir, a_currentTime);
}
int exe(FILE* program) //program指向存有待执行程序机器码的文件
{
char* tmp_instru=(char*)malloc(33*sizeof(char)); //读机器码
programTail=programHead;
while(fscanf(program,"%s",tmp_instru)!=EOF)
{
instru=0;
int i=0;
unsigned j=1;
for(i=31;i>=0;i--)
{
if(tmp_instru[i]=='1')
{
instru+=j;
j*=2;
}
else
{
j*=2;
}
}//将机器码转为unsi
unsigned char* tmp_R=&instru;
for(i=0;i<4;i++)
{
writeMymemory(programTail+i,tmp_R+i);//装载指令
}
programTail+=4;//最后一条指令的下一条指令的地址，用来判断程序是否执行完
}
pcShort=programHead;
pc=pcShort;
while(pcShort!=programTail)
{
instru=0; //指令寄存器清零
unsigned char* tmp_R=&instru;
unsigned short addr=addrToMyAddr(pc);
int i;
for(i=0;i<4;i++)
{
readMymemory(addr+i,tmp_R+i);//取指令
}
unsigned tmp=instru>>26;//得到指令op
//printf("the op is : %u\n",tmp);
unsigned numRs=0,numRt=0,numRd=0,numFs=0,numFt=0,numFd=0,tmp_fuc=0;
switch(tmp)
{
case 0x00000023:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=lw(pc);
break;
case 0x0000002B:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=sw(pc);
break;
case 0x00000008:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=addi(pc);
break;
case 0x00000009:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=addiu(pc);
break;
case 0x0000000A:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=slti(pc);
break;
case 0x0000000B:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=sltiu(pc);
break;
case 0x0000000C:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=andi(pc);
break;
case 0x0000000D:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=ori(pc);
break;
case 0x0000000E:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=xori(pc);
break;
case 0x00000024:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=lbu(pc);
break;
case 0x00000020:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=lb(pc);
break;
case 0x00000028:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=sb(pc);
break;
case 0x0000000F:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=lui(pc);
break;
case 0x00000004:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=beq(pc);
break;
case 0x00000005:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
//printf("%u,%u,%u,%u\n",numRt,numRs,*RS1,*RS2);
lig=instru<<16>>16;
// printf("%u\n",lig);
pc=bne(pc);
break;
case 0x00000006:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=blez(pc);
break;
case 0x00000007:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=bgtz(pc);
break;
case 0x00000001:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
lig=instru<<16>>16;
pc=bltz(pc);
break;
case 0x00000002:
pc=j(pc);
break;
case 0x00000003:
pc=jal(pc);
break;
case 0x00000000:
numRs=instru<<6>>27;
numRt=instru<<11>>27;
numRd=instru<<16>>27;
RS1=myRegister+numRt;
RS2=myRegister+numRs;
RD=myRegister+numRd;
tmp_fuc=instru%64;
switch(tmp_fuc)
{
case 32:
pc=add(pc);
break;
case 33:
pc=addu(pc);
break;
case 34:
pc=sub(pc);
break;
case 35:
pc=subu(pc);
break;
case 24:
pc=mul(pc);
break;
case 25:
pc=mulu(pc);
break;
case 26:
pc=myDiv(pc);
break;
case 27:
pc=divu(pc);
break;
case 42:
pc=slt(pc);
break;
case 43:
pc=sltu(pc);
break;
case 36:
pc=myAnd(pc);
break;
case 37:
pc=myOr(pc);
break;
case 39:
pc=nor(pc);
break;
case 40:
pc=myXor(pc);
break;
case 8:
pc=jr(pc);
break;
case 9:
pc=jalr(pc);
break;
case 0:
pc=nop(pc);
break;
case 16:
pc=mfhi(pc);
break;
case 18:
pc=mflo(pc);
break;
default:
break;
}
break;
case 0x00000010:
numRt=instru<<11>>27;
numRd=instru<<16>>27;
RS1=myRegister+numRt;
if(numRd==14)
{
pc=mfepc(pc);
}
else if(numRd==13)
{
pc=mfco(pc);
}
else return -1;
break;
case 0x00000031:
numRs=instru<<6>>27;
numFt=instru<<11>>27;
RS2=myRegister+numRs;
FS1=myFloatReg+numFt;
lig=instru<<16>>16;
pc=lwc1(pc);
//printf("/********\nL.S %u %u\n****************/\n",numFt,numRs);
break;
case 0x0000001F:
numRs=instru<<6>>27;
numFt=instru<<11>>27;
RS2=myRegister+numRs;
FS1=myFloatReg+numFt;
lig=instru<<16>>16;
pc=S_D(pc);
//printf("/********\nL.D %u %u\n****************/\n",numFt,numRs);
break;
case 0x0000001E:
numRs=instru<<6>>27;
numFt=instru<<11>>27;
RS2=myRegister+numRs;
FS1=myFloatReg+numFt;
lig=instru<<16>>16;
//printf("/********\nS.D %u %u\n****************/\n",numFt,numRs);
pc=S_D(pc);
break;
case 0x00000039:
numRs=instru<<6>>27;
numFt=instru<<11>>27;
RS2=myRegister+numRs;
FS1=myFloatReg+numFt;
lig=instru<<16>>16;
//printf("/********\nS.S %u %u\n****************/\n",numFt,numRs);
pc=swc1(pc);
break;
case 0x00000011:
numFt=instru<<11>>27;
numFs=instru<<16>>27;
numFd=instru<<21>>27;
FS1=myFloatReg+numFt;
FS2=myFloatReg+numFs;
FD=myFloatReg+numFd;
numRs=instru<<6>>27;
tmp_fuc=instru%64;
//printf("%u %u\n",tmp_fuc,numRs);
if(numRs==0)
{
switch(tmp_fuc)
{
case 0:
pc=add_s(pc);
break;
case 1:
pc=sub_s(pc);
break;
case 2:
pc=mul_s(pc);
case 3:
pc=div_s(pc);
default:
break;
}
}
else if(numRs==1)
{
switch(tmp_fuc)
{
case 0:
pc=add_d(pc);
//printf("/****************\nADD.D %u %u %u\n*****************/\n",numFd,numFt,numFs);
break;
case 1:
pc=sub_d(pc);
break;
case 2:
pc=mul_d(pc);
case 3:
pc=div_d(pc);
default:
break;
}
}
default:break;
}
pcShort=pc%0x00010000;
//printf("%u %u\n",pc,pcShort);
//printf("%u %u\n",pcShort,programTail);
}
return 0;
}