veryLong veryLong::operator/(veryLong n1)
{
veryLong n;
unsigned char *ostatok;
int lenOst;
if (!binary)
{
if (((znak=='+')&&(n1.znak=='+'))||((znak=='-')&&(n1.znak=='-')))
{
n.number = divv(&number,&n1.number,&ostatok);
n.znak='+';
}
else
{
n.number = divv(&number,&n1.number,&ostatok);
n.znak='-';
}
n.lenght = strlenn(&n.number);
n.binary=binary;
}
else
{
turnb(&number,lenght);
turnb(&n1.number,n1.lenght);
n.number = divvb(&number,&n1.number,lenght,n1.lenght,&n.lenght,&ostatok,&lenOst);
n.binary=binary;
turnb(&number,lenght);
turnb(&n1.number,n1.lenght);
turnb(&n.number,n.lenght);
}
return n;
}
void
Navierstokes::exportResults( double time, element_type& U )
{
auto u = U.element<0>();
auto p = U.element<1>();
auto v = V.element<0>();
auto q = V.element<1>();
#if defined( FEELPP_USE_LM )
auto lambda = U.element<2>();
auto nu = V.element<2>();
LOG(INFO) << "value of the Lagrange multiplier lambda= " << lambda( 0 ) << "\n";
#endif
double div_u_error_L2 = normL2( _range=elements( u.mesh() ), _expr=divv( u ) );
LOG(INFO) << "[navierstokes] ||div(u)||_2=" << div_u_error_L2 << "\n";
if ( exporter->doExport() )
{
exporter->step( time )->setMesh( U.functionSpace()->mesh() );
exporter->step( time )->addRegions();
exporter->step( time )->add( {"u","p","l"}, U );
exporter->save();
}
} // NavierStokes::export
int main(int argc, char *argv[])
{
int sZahlen[10];
int i=0;
for(i=1; i<argc; ++i)
{
sZahlen[i-1] = atoi(argv[i]);
}
if(strcmp(argv[1], "add") == 0)
{
if(sZahlen[2] != sZahlen[4])
GleichSetzen(sZahlen);
add(sZahlen);
}
if(strcmp(argv[1], "mul") == 0)
{
mul(sZahlen);
}
if(strcmp(argv[1], "sub") == 0)
{
if(sZahlen[2] != sZahlen[4])
GleichSetzen(sZahlen);
sub(sZahlen);
}
if(strcmp(argv[1], "div") == 0)
{
divv(sZahlen);
}
/**************************
**************************/
/*AUSHABE*/
kuerzen(sZahlen);
printf("\nErgebnis: %d / %d\n", sZahlen[8], sZahlen[9]);
return 0;
}
veryLong veryLong::operator%(veryLong n1)
{
veryLong n;
unsigned char *ostatok;
int lenOst;
if (!binary)
{
divv(&number,&n1.number,&n.number);
n.lenght = strlenn(&n.number);
n.binary=binary;
}
else
{
turnb(&number,lenght);
turnb(&n1.number,n1.lenght);
divvb(&number,&n1.number,lenght,n1.lenght,&lenOst,&n.number,&n.lenght);
n.binary=binary;
turnb(&number,lenght);
turnb(&n1.number,n1.lenght);
turnb(&n.number,n.lenght);
}
return n;
}
void
DrivenCavity<Dim>::Residual(const vector_ptrtype& X, vector_ptrtype& R)
{
auto U = Vh->element( "(u,p)" );
auto V = Vh->element( "(v,q)" );
auto u = U.template element<0>( "u" );
//auto u_exact = U.template element<0>( "u_exact" );
auto v = V.template element<0>( "u" );
auto p = U.template element<1>( "p" );
auto q = V.template element<1>( "p" );
//#if defined( FEELPP_USE_LM )
auto lambda = U.template element<2>();
auto nu = V.template element<2>();
//#endif
auto uex=unitX();
auto u_exact=vf::project(Vh->template functionSpace<0>(), markedfaces(mesh, "wall2"), uex );
U=*X;
auto r = form1( _test=Vh, _vector=R );
//r += integrate( elements( mesh ),-inner( f,id( v ) ) );
r = integrate( elements( mesh ), trans(gradv( u )*idv(u))*id(v));//convective term
r += integrate( elements( mesh ), inner(gradv( u ),grad( v ))/Re );
r += integrate( elements( mesh ),-idv(p)*div(v) + id(q)*divv(u));
//#if defined( FEELPP_USE_LM )
r += integrate ( elements( mesh ), +id( q )*idv( lambda )+idv( p )*id( nu ) );
//#endif
//Weak Dirichlet
auto SigmaNv = ( -idv( p )*N() + gradv( u )*N()/Re );
auto SigmaN = ( -id( q )*N() + grad( v )*N()/Re );
r +=integrate ( boundaryfaces(mesh), - trans( SigmaNv )*id( v ) - trans( SigmaN )*( idv( u ) -idv(u_exact) ) + penalbc*trans( idv( u ) - idv(u_exact) )*id( v )/hFace() );
}
void
starform_func()
{
int i ;
struct gas_particle *gp ;
double tdyn ;
double tcool ;
double tsound ;
double tempvect ;
double soft ;
double formtime ;
double adiabatic ;
double srhomin ;
if (!cooling_loaded ){
cool_func() ;
}
if (!meanmwt_loaded ){
meanmwt_func() ;
}
if(!form_loaded ){
load_form() ;
}
if(!epsgas_loaded){
load_epsgas() ;
}
if(!divv_loaded){
divv() ;
}
if(!dudt_loaded){
calc_dudt() ;
}
srhomin = rhomin*pow(kpcunit*KPCCM, 3.0)/(MSOLG*msolunit)/fhydrogen*MHYDR ;
if(starform != NULL) free(starform);
if(boxlist[active_box].ngas != 0) {
starform =
(double *)malloc(boxlist[0].ngas *sizeof(*starform));
if(starform == NULL) {
printf("<sorry, no memory for starform, %s>\n",title) ;
return ;
}
}
else
starform = NULL;
for (i = 0 ;i < boxlist[0].ngas ;i++) {
gp = boxlist[0].gp[i] ;
if(hsmdivv[gp-gas_particles] < 0.) {
tdyn = GYRSEC*time_unit/sqrt(4.*(gp->rho/cosmof3)*PI);
adiabatic = -KBOLTZ*gp->temp*
gp->rho/(MHYDR*meanmwt[gp-gas_particles])*
(hsmdivv[gp-gas_particles]/gp->hsmooth)*MSOLG*msolunit/
(cosmof3*pow(kpcunit*KPCCM, 3.0))/time_unit/GYRSEC ;
adiabatic = dudt[gp-gas_particles]*(gp->rho) /(kpcunit*KPCCM) /
(time_unit*GYRSEC*time_unit*GYRSEC*time_unit*GYRSEC) ;
tcool = 1.5*KBOLTZ*gp->temp*MSOLG*msolunit*gp->rho/
(MHYDR*meanmwt[gp-gas_particles])/
(cosmof3*pow(kpcunit*KPCCM, 3.0))/
(cooling[gp-gas_particles] + adiabatic) ;
tsound = kpcunit*KPCCM*gp->hsmooth*cosmof
/sqrt(GAMMA*KBOLTZ*gp->temp/(MHYDR*meanmwt[gp-gas_particles])) ;
soft = .89553 * (PI*epsgas_grav*cosmof)*(PI*epsgas_grav*cosmof) /
2. * meanmwt[gp-gas_particles]*MHYDR*(gp->rho /
(KBOLTZ*gp->temp)) *(kpcunit*kpcunit*KPCCM*KPCCM
/time_unit/time_unit/GYRSEC/GYRSEC) ;
if((tdyn > fabs(tcool) || gp->temp <= temppar)){
formtime = tdyn ;
}
else{
formtime = fabs(tcool) ;
}
formtime /= time_unit*GYRSEC ;
if((tcool < 0. || gp->temp <= temppar)
&& (tsound > tdyn || soft > softpar) &&
gp->rho/cosmof3 >= srhomin && gp->rho >= overmin){
tempvect = formtime ;
starform[i] = (1.- exp(-cstar * dtime / tempvect))*gp->mass*
stareff*msolunit/dtime/time_unit/1.e9;
}
else{
starform[i] = 0. ;
}
}
else{
starform[i] = 0. ;
}
}
starform_loaded = YES ;
}
int main(int argc, char *argv[])
{
char *inputFirst,*inputSecond,*inputThird;
FILE *output;
int lenghtFirst,lenghtSecond,i,binary,module,lenghtModule;
unsigned char *numberOne,*numberTwo,*ostatok,*numModule;
unsigned char znak1,znak2,znak3;
char znak;
if (argc < 5 )
{
printf("\nEnter correct parameters\n");
return 0;
}
if (argc == 7)
{
binary=1;
module=1;
inputThird=argv[6];
lenghtModule = readb(&numModule,inputThird);
}
if (argc == 6)
{
if (strcmp(argv[5],"-b") == 0)
{
binary=1;
module=0;
}
else
{
binary=0;
module=1;
inputThird=argv[5];
lenghtModule = readd(&numModule,inputThird,&znak3);
}
}
if (argc < 6)
{
binary=0;
module=0;
}
inputFirst =argv[1];
inputSecond=argv[3];
if(!binary)
{
output = fopen(argv[4],"w");
}
else
{
output = fopen(argv[4],"wb");
}
znak=argv[2][0];
switch(znak)
{
case '+' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
turn(&numberOne);
turn(&numberTwo);
if ((znak1=='+')&&(znak2=='+'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
break;
}
if ((znak1=='-')&&(znak2=='-'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
break;
}
if ((znak1=='+')&&(znak2=='-'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
break;
}
if ((znak1=='-')&&(znak2=='+'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
break;
}
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
numberOne=summb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst);
fwrite(numberOne,lenghtFirst,1,output);
}
break;
case '-' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
turn(&numberOne);
turn(&numberTwo);
if ((znak1=='+')&&(znak2=='+'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
break;
}
if ((znak1=='-')&&(znak2=='-'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
break;
}
if ((znak1=='+')&&(znak2=='-'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
break;
}
if ((znak1=='-')&&(znak2=='+'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
break;
}
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
numberOne=subb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst);
fwrite(numberOne,lenghtFirst,1,output);
}
break;
case '*' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
turn(&numberOne);
turn(&numberTwo);
if (((znak1=='+')&&(znak2=='+'))||((znak1=='-')&&(znak2=='-')))
{
numberOne=mul(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne=mul(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
numberOne=mulb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst);
fwrite(numberOne,lenghtFirst,1,output);
}
break;
case '/' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
if (((znak1=='+')&&(znak2=='+'))||((znak1=='-')&&(znak2=='-')))
{
fprintf(output,"%s",divv(&numberOne,&numberTwo,&ostatok));
}
else
{
fprintf(output,"-%s",divv(&numberOne,&numberTwo,&ostatok));
}
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
turnb(&numberOne,lenghtFirst);
turnb(&numberTwo,lenghtSecond);
numberOne=divvb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst,&ostatok,&lenghtSecond);
turnb(&numberOne,lenghtFirst);
fwrite(numberOne,lenghtFirst,1,output);
}
break;
case '%' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
divv(&numberOne,&numberTwo,&ostatok);
fprintf(output,"%s",ostatok);
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
turnb(&numberOne,lenghtFirst);
turnb(&numberTwo,lenghtSecond);
divvb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst,&ostatok,&lenghtSecond);
turnb(&ostatok,lenghtSecond);
fwrite(ostatok,lenghtSecond,1,output);
free(ostatok);
}
break;
case '^' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
turn(&numberOne);
turn(&numberTwo);
numberOne=stepen(&numberOne,&numberTwo,&znak1);
turn(&numberOne);
if (znak1=='+')
fprintf(output,"%s",numberOne);
else
fprintf(output,"-%s",numberOne);
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
numberOne=stepenb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst);
fwrite(numberOne,lenghtFirst,1,output);
}
break;
default:
break;
}
fclose(output);
if (module)
{
if(!binary)
{
output = fopen(argv[4],"w");
divv(&numberOne,&numModule,&ostatok);
fprintf(output,"%s",ostatok);
}
else
{
output = fopen(argv[4],"wb");
turnb(&numberOne,lenghtFirst);
turnb(&numModule,lenghtModule);
divvb(&numberOne,&numModule,lenghtFirst,lenghtModule,&lenghtFirst,&ostatok,&lenghtModule);
turnb(&ostatok,lenghtModule);
fwrite(ostatok,lenghtModule,1,output);
}
fclose(output);
}
return 0;
}
void
calc_dudt()
{
struct gas_particle *gp ;
KD kd;
int n_smooth = 64;
float period[MAXDIM];
int i;
double rsys, vsys;
if (boxlist[0].ngas != header.nsph) {
printf("<Warning, box 0 does not contain all particles, %s>\n", title);
printf("<Reloading box 0, %s>\n", title);
loadall();
}
if (!dkernel_loaded){
dkernel_load() ;
}
if (!redshift_loaded){
load_redshift() ;
}
if (!cool_loaded ){
load_cool() ;
}
if (!visc_loaded) {
load_visc();
}
if (!divv_loaded) {
divv();
}
if (!meanmwt_loaded) {
meanmwt_func() ;
}
rsys = kpcunit/1.e3 ;
vsys = sqrt(msolunit/kpcunit*(GCGS*MSOLG/KPCCM))/1.e5 ;
hsys = rsys*hubble_constant/vsys;
if (dudt != NULL){
free(dudt);
}
if (boxlist[0].ngas != 0) {
dudt = (double *)malloc(boxlist[0].ngas *sizeof(*dudt));
if (dudt == NULL) {
printf("<sorry, no memory for hsmdivv, %s>\n",title) ;
return ;
}
}
else
dudt = NULL;
if (box0_smx) {
kdFinish(box0_smx->kd);
smFinish(box0_smx);
box0_smx = NULL;
}
printf("<Building tree, %s>\n", title);
kdInit(&kd);
kdReadBox(kd, &boxlist[0], 0, 1, 0);
kdBuildTree(kd);
if (periodic)
period[0] = period[1] = period[2] = period_size;
else
period[0] = period[1] = period[2] = 1e37;
printf("<Calculating dudt, %s>\n", title);
smInit(&box0_smx,kd,n_smooth,period);
smSetBallh(box0_smx);
smReSmooth(box0_smx,smDudtSym);
kdOrder(kd);
for(i = 0; i < boxlist[0].ngas; i++) {
gp = boxlist[0].gp[i];
dudt[i] = 0.5 * kd->p[i].fDensity;
}
dudt_loaded = YES ;
starform_loaded = NO ;
}
int main(int argc, char *argv[])
{
FILE *output;
char *inputFirst,*inputSecond,*inputThird;
int lengthFirst,lengthSecond,i,binary,module,lengthModule;
unsigned char *numberOne,*numberTwo,*remainder,*numModule;
unsigned char sign1,sign2,sign3;
char sign;
if (argc < 5 )
{
printf("\nEnter correct parameters\n");
return 0;
}
if (argc < 6)
{
binary=0;
module=0;
}
if (argc == 6)
{
if (strcmp(argv[5],"-b") == 0)
{
binary=1;
module=0;
}
else
{
binary=0;
module=1;
inputThird=argv[5];
lengthModule = readd(&numModule,inputThird,&sign3);
}
}
if (argc == 7)
{
binary=1;
module=1;
inputThird=argv[6];
lengthModule = readb(&numModule,inputThird);
}
inputFirst =argv[1];
inputSecond=argv[3];
if(!binary)
{
output = fopen(argv[4],"w");
}
else
{
output = fopen(argv[4],"wb");
}
sign=argv[2][0];
switch(sign)
{
case '+' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
turn(&numberOne);
turn(&numberTwo);
if ((sign1=='+')&&(sign2=='+'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
break;
}
if ((sign1=='-')&&(sign2=='-'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
break;
}
if ((sign1=='+')&&(sign2=='-'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
break;
}
if ((sign1=='-')&&(sign2=='+'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
break;
}
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
numberOne=summb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst);
fwrite(numberOne,lengthFirst,1,output);
}
break;
case '-' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
turn(&numberOne);
turn(&numberTwo);
if ((sign1=='+')&&(sign2=='+'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
break;
}
if ((sign1=='-')&&(sign2=='-'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
break;
}
if ((sign1=='+')&&(sign2=='-'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
break;
}
if ((sign1=='-')&&(sign2=='+'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
break;
}
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
numberOne=subb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst);
fwrite(numberOne,lengthFirst,1,output);
}
break;
case '*' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
turn(&numberOne);
turn(&numberTwo);
if (((sign1=='+')&&(sign2=='+'))||((sign1=='-')&&(sign2=='-')))
{
numberOne=mul(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne=mul(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
numberOne=mulb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst);
fwrite(numberOne,lengthFirst,1,output);
}
break;
case '/' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
if (((sign1=='+')&&(sign2=='+'))||((sign1=='-')&&(sign2=='-')))
{
fprintf(output,"%s",divv(&numberOne,&numberTwo,&remainder));
}
else
{
fprintf(output,"-%s",divv(&numberOne,&numberTwo,&remainder));
}
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
turnb(&numberOne,lengthFirst);
turnb(&numberTwo,lengthSecond);
numberOne=divvb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst,&remainder,&lengthSecond);
turnb(&numberOne,lengthFirst);
fwrite(numberOne,lengthFirst,1,output);
}
break;
case '%' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
divv(&numberOne,&numberTwo,&remainder);
fprintf(output,"%s",remainder);
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
turnb(&numberOne,lengthFirst);
turnb(&numberTwo,lengthSecond);
divvb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst,&remainder,&lengthSecond);
turnb(&remainder,lengthSecond);
fwrite(remainder,lengthSecond,1,output);
free(remainder);
}
break;
case '^' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
turn(&numberOne);
turn(&numberTwo);
numberOne=degree(&numberOne,&numberTwo,&sign1);
turn(&numberOne);
if (sign1=='+')
fprintf(output,"%s",numberOne);
else
fprintf(output,"-%s",numberOne);
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
numberOne=degreeb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst);
fwrite(numberOne,lengthFirst,1,output);
}
break;
default:
break;
}
fclose(output);
if (module)
{
if(!binary)
{
output = fopen(argv[4],"w");
divv(&numberOne,&numModule,&remainder);
fprintf(output,"%s",remainder);
}
else
{
output = fopen(argv[4],"wb");
turnb(&numberOne,lengthFirst);
turnb(&numModule,lengthModule);
divvb(&numberOne,&numModule,lengthFirst,lengthModule,&lengthFirst,&remainder,&lengthModule);
turnb(&remainder,lengthModule);
fwrite(remainder,lengthModule,1,output);
}
fclose(output);
}
return 0;
}
