/*! \brief It convert the box from the domain decomposition into sub-domain * * The decomposition box from the domain-decomposition contain the box in integer * coordinates * * \param loc_box local box * * \return the corresponding sib-domain * */ SpaceBox<dim,T> convertDecBoxIntoSubDomain(const SpaceBox<dim,size_t> & loc_box) { // A point with all coordinate to one size_t one[dim]; for (size_t i = 0 ; i < dim ; i++) {one[i] = 1;} SpaceBox<dim, size_t> sub_dc = loc_box; SpaceBox<dim, size_t> sub_dce = sub_dc; sub_dce.expand(one); SpaceBox<dim, T> sub_d(sub_dce); sub_d.mul(spacing); sub_d += domain.getP1(); // we add the // Fixing sub-domains to cover all the domain // Fixing sub_d // if (loc_box) is at the boundary we have to ensure that the box span the full // domain (avoiding rounding off error) for (size_t i = 0; i < dim; i++) { if (sub_dc.getHigh(i) == cd.getGrid().size(i) - 1) sub_d.setHigh(i, domain.getHigh(i)); if (sub_dc.getLow(i) == 0) sub_d.setLow(i,domain.getLow(i)); } return sub_d; }
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; }
int sphere_eval_d(point_d funcVals, point_d parVals, vec_d parDer, mat_d Jv, mat_d Jp, point_d current_variable_values, comp_d pathVars, void const *ED) { // evaluates a special homotopy type, built for bertini_real sphere_eval_data_d *BED = (sphere_eval_data_d *)ED; // to avoid having to cast every time BED->SLP_memory.set_globals_to_this(); int ii, jj, mm; // counters int offset; comp_d one_minus_s, gamma_s; comp_d temp, temp2; comp_d func_val_sphere, func_val_start; set_one_d(one_minus_s); sub_d(one_minus_s, one_minus_s, pathVars); // one_minus_s = (1 - s) mul_d(gamma_s, BED->gamma, pathVars); // gamma_s = gamma * s vec_d patchValues; init_vec_d(patchValues, 0); vec_d temp_function_values; init_vec_d(temp_function_values,0); vec_d AtimesF; init_vec_d(AtimesF,BED->randomizer()->num_rand_funcs()); AtimesF->size = BED->randomizer()->num_rand_funcs();// declare // initialize mat_d temp_jacobian_functions; init_mat_d(temp_jacobian_functions,BED->randomizer()->num_base_funcs(),BED->num_variables); temp_jacobian_functions->rows = BED->randomizer()->num_base_funcs(); temp_jacobian_functions->cols = BED->num_variables; mat_d temp_jacobian_parameters; init_mat_d(temp_jacobian_parameters,0,0); mat_d Jv_Patch; init_mat_d(Jv_Patch, 0, 0); mat_d AtimesJ; init_mat_d(AtimesJ,BED->randomizer()->num_rand_funcs(),BED->num_variables); AtimesJ->rows = BED->randomizer()->num_rand_funcs(); AtimesJ->cols = BED->num_variables; //set the sizes change_size_vec_d(funcVals,BED->num_variables); funcVals->size = BED->num_variables; change_size_mat_d(Jv, BED->num_variables, BED->num_variables); Jv->rows = Jv->cols = BED->num_variables; // -> this should be square!!! for (ii=0; ii<BED->num_variables; ii++) for (jj=0; jj<BED->num_variables; jj++) set_zero_d(&Jv->entry[ii][jj]); // evaluate the SLP to get the system's whatnot. evalProg_d(temp_function_values, parVals, parDer, temp_jacobian_functions, temp_jacobian_parameters, current_variable_values, pathVars, BED->SLP); // evaluate the patch patch_eval_d(patchValues, parVals, parDer, Jv_Patch, Jp, current_variable_values, pathVars, &BED->patch); // Jp is ignored // we assume that the only parameter is s = t and setup parVals & parDer accordingly. // note that you can only really do this AFTER you are done calling other evaluators. // set parVals & parDer correctly // i.e. these must remain here, or below. \/ change_size_point_d(parVals, 1); change_size_vec_d(parDer, 1); change_size_mat_d(Jp, BED->num_variables, 1); Jp->rows = BED->num_variables; Jp->cols = 1; for (ii=0; ii<BED->num_variables; ii++) set_zero_d(&Jp->entry[ii][0]); parVals->size = parDer->size = 1; set_d(&parVals->coord[0], pathVars); // s = t set_one_d(&parDer->coord[0]); // ds/dt = 1 /////////////////////////// // // the original (randomized) functions. // /////////////////////////////////// BED->randomizer()->randomize(AtimesF,AtimesJ,temp_function_values,temp_jacobian_functions,¤t_variable_values->coord[0]); for (ii=0; ii<AtimesF->size; ii++) // for each function, after (real orthogonal) randomization set_d(&funcVals->coord[ii], &AtimesF->coord[ii]); for (ii = 0; ii < BED->randomizer()->num_rand_funcs(); ii++) for (jj = 0; jj < BED->num_variables; jj++) set_d(&Jv->entry[ii][jj],&AtimesJ->entry[ii][jj]); //Jp is 0 for the equations. /////////////////// // // the sphere equation. // ////////////////////////// offset = BED->randomizer()->num_rand_funcs(); mul_d(func_val_sphere, BED->radius, BED->radius); neg_d(func_val_sphere, func_val_sphere); mul_d(func_val_sphere, func_val_sphere, ¤t_variable_values->coord[0]); mul_d(func_val_sphere, func_val_sphere, ¤t_variable_values->coord[0]); //f_sph = -r^2*h^2 for (int ii=1; ii<BED->num_natural_vars; ii++) { mul_d(temp2, &BED->center->coord[ii-1], ¤t_variable_values->coord[0]); // temp2 = c_{i-1}*h sub_d(temp, ¤t_variable_values->coord[ii], temp2); // temp = x_i - h*c_{i-1} mul_d(temp2, temp, temp); // temp2 = (x_i - h*c_{i-1})^2 add_d(func_val_sphere, func_val_sphere, temp2); // f_sph += (x_i - h*c_{i-1})^2 } set_one_d(func_val_start); for (mm=0; mm<2; ++mm) { dot_product_d(temp, BED->starting_linear[mm], current_variable_values); mul_d(func_val_start, func_val_start, temp); //f_start *= L_i (x) } // combine the function values mul_d(temp, one_minus_s, func_val_sphere); mul_d(temp2, gamma_s, func_val_start); add_d(&funcVals->coord[offset], temp, temp2); // f = (1-t) f_sph + gamma t f_start //// / / / / / / now the derivatives wrt x // first we store the derivatives of the target function, the sphere. then we will add the part for the linear product start. //ddx for sphere for (int ii=1; ii<BED->num_natural_vars; ii++) { mul_d(temp2, &BED->center->coord[ii-1], ¤t_variable_values->coord[0]); // temp2 = c_{i-1}*h sub_d(temp, ¤t_variable_values->coord[ii], temp2) // temp = x_i - c_{i-1}*h mul_d(&Jv->entry[offset][ii], BED->two, temp); // Jv = 2*(x_i - c_{i-1}*h) mul_d(&Jv->entry[offset][ii], &Jv->entry[offset][ii], one_minus_s); // Jv = (1-t)*2*(x_i - c_{i-1}*h) // multiply these entries by (1-t) mul_d(temp2, &BED->center->coord[ii-1], temp); // temp2 = c_{i-1} * ( x_i - c_{i-1} * h ) add_d(&Jv->entry[offset][0], &Jv->entry[offset][0], temp2); // Jv[0] += c_{i-1} * ( x_i - c_{i-1} * h ) } // the homogenizing var deriv mul_d(temp, ¤t_variable_values->coord[0], BED->radius); mul_d(temp, temp, BED->radius); // temp = r^2 h add_d(&Jv->entry[offset][0], &Jv->entry[offset][0], temp); // Jv[0] = \sum_{i=1}^n {c_{i-1} * ( x_i - c_{i-1} * h )} + r^2 h neg_d(&Jv->entry[offset][0], &Jv->entry[offset][0]); // Jv[0] = -Jv[0] mul_d(&Jv->entry[offset][0], &Jv->entry[offset][0], BED->two); // Jv[0] *= 2 mul_d(&Jv->entry[offset][0], &Jv->entry[offset][0], one_minus_s); // Jv[0] *= (1-t) // f = \sum{ ( x_i - c_{i-1} * h )^2 } - r^2 h^2 //Jv[0] = -2(1-t) ( \sum_{i=1}^n { c_{i-1} * ( x_i - c_{i-1} * h ) } + r^2 h ) // a hardcoded product rule for the two linears. for (int ii=0; ii<BED->num_variables; ii++) { dot_product_d(temp, BED->starting_linear[0], current_variable_values); mul_d(temp, temp, &BED->starting_linear[1]->coord[ii]); dot_product_d(temp2, BED->starting_linear[1], current_variable_values); mul_d(temp2, temp2, &BED->starting_linear[0]->coord[ii]); add_d(temp, temp, temp2); mul_d(temp2, temp, gamma_s); //temp2 = gamma s * (L_1(x) * L_0[ii] + L_0(x) * L_1[ii]) //temp2 now has the value of the derivative of the start system wrt x_i add_d(&Jv->entry[offset][ii], &Jv->entry[offset][ii], temp2); } //// // / / /// // // finally, the Jp entry for sphere equation's homotopy. //Jp = -f_sph + gamma f_start neg_d(&Jp->entry[offset][0], func_val_sphere); mul_d(temp, BED->gamma, func_val_start); add_d(&Jp->entry[offset][0], &Jp->entry[offset][0], temp); ////////////// // // function values for the static linears // //////////////////// offset++; for (mm=0; mm<BED->num_static_linears; ++mm) { dot_product_d(&funcVals->coord[mm+offset], BED->static_linear[mm], current_variable_values); } for (mm=0; mm<BED->num_static_linears; ++mm) { for (ii=0; ii<BED->num_variables; ii++) { set_d(&Jv->entry[mm+offset][ii], &BED->static_linear[mm]->coord[ii]); } } //Jp is 0 for the static linears ////////////// // // the entries for the patch equations. // //////////////////// if (offset+BED->num_static_linears != BED->num_variables-BED->patch.num_patches) { std::cout << color::red() << "mismatch in offset!\nleft: " << offset+BED->num_static_linears << " right " << BED->num_variables-BED->patch.num_patches << color::console_default() << std::endl; mypause(); } offset = BED->num_variables-BED->patch.num_patches; for (ii=0; ii<BED->patch.num_patches; ii++) set_d(&funcVals->coord[ii+offset], &patchValues->coord[ii]); for (ii = 0; ii<BED->patch.num_patches; ii++) // for each patch equation { // Jv = Jv_Patch for (jj = 0; jj<BED->num_variables; jj++) // for each variable set_d(&Jv->entry[ii+offset][jj], &Jv_Patch->entry[ii][jj]); } //Jp is 0 for the patch. // done! yay! if (BED->verbose_level()==16 || BED->verbose_level()==-16) { //uncomment to see screen output of important variables at each solve step. print_point_to_screen_matlab(BED->center,"center"); print_comp_matlab(BED->radius,"radius"); printf("gamma = %lf+1i*%lf;\n", BED->gamma->r, BED->gamma->i); printf("time = %lf+1i*%lf;\n", pathVars->r, pathVars->i); print_point_to_screen_matlab(current_variable_values,"currvars"); print_point_to_screen_matlab(funcVals,"F"); print_matrix_to_screen_matlab(Jv,"Jv"); print_matrix_to_screen_matlab(Jp,"Jp"); } BED->SLP_memory.set_globals_null(); clear_vec_d(patchValues); clear_vec_d(temp_function_values); clear_vec_d(AtimesF); clear_mat_d(temp_jacobian_functions); clear_mat_d(temp_jacobian_parameters); clear_mat_d(Jv_Patch); clear_mat_d(AtimesJ); #ifdef printpathsphere BED->num_steps++; vec_d dehommed; init_vec_d(dehommed,BED->num_variables-1); dehommed->size = BED->num_variables-1; dehomogenize(&dehommed,current_variable_values); fprintf(BED->FOUT,"%.15lf %.15lf ", pathVars->r, pathVars->i); for (ii=0; ii<BED->num_variables-1; ++ii) { fprintf(BED->FOUT,"%.15lf %.15lf ",dehommed->coord[ii].r,dehommed->coord[ii].i); } fprintf(BED->FOUT,"\n"); clear_vec_d(dehommed); #endif return 0; }