bignum& bignum::sum(const bignum& value, bool same_sign) { if(same_sign) { if(value_ == value.value_) { value_.reset(); sign_ = false; } else if(value_ < value.value_) { sign_ = !sign_; value_ = substract(value.value_, value_); } else value_ = substract(value_, value.value_); } else { if(value_.check_adding_overflow(value.value_)) throw_with_nested(overflow_error("number is too big")); value_ = add(value_, value.value_); } return *this; }
pair<bits_value, bits_value> bignum::bits_divide(const bits_value& dividend, const bits_value& divisor) { bits_size_t cursor = dividend.bits_span() - divisor.bits_span(); bits_value divided; bits_value remainder = dividend >> cursor; while(cursor > 0) { if(remainder < divisor) { divided <<= 1; remainder <<= 1; remainder.set(0, dividend.test(--cursor)); } else { remainder = substract(remainder, divisor); divided.set(0); } } if(!(remainder < divisor)) { divided.set(0); remainder = substract(remainder, divisor); } return make_pair(move(divided), move(remainder)); }
int main() { fixed_16_16_t a = double_to_fixed_16_16(12.6798d); fixed_16_16_t b = double_to_fixed_16_16(1.2d); fixed_16_16_t c = double_to_fixed_16_16(0.6669776578d); fixed_16_16_t d = double_to_fixed_16_16(-3.1d); fixed_16_16_t e = double_to_fixed_16_16(55.0d); fixed_16_16_t f = double_to_fixed_16_16(0.2d); printf("initial a=%.4f\n", fixed_16_16_to_double(a)); printf("initial b=%.2f\n", fixed_16_16_to_double(b)); printf("initial c=%.2f\n", fixed_16_16_to_double(c)); printf("initial d=%.2f\n", fixed_16_16_to_double(d)); printf("initial e=%.2f\n", fixed_16_16_to_double(e)); printf("initial f=%.16f\n", fixed_16_16_to_double(f)); fixed_16_16_t adding_value = add(a, b); printf("adding result=%.4f\n", fixed_16_16_to_double(adding_value)); fixed_16_16_t substraction_value = substract(d, f); printf("substraction result=%.2f\n", fixed_16_16_to_double(substraction_value)); fixed_16_16_t multiplication_value = multiply(e, d); printf("multiplication result=%.4f\n", fixed_16_16_to_double(multiplication_value)); fixed_16_16_t division_value = divide(b, f); printf("division result=%.16f\n", fixed_16_16_to_double(division_value)); return 0; }
char *getDivider(int portion, char *n1, const char *n2) { char *multiplier = strdup("0"); char *tmp = 0; int ret; do { free(tmp); tmp = multiplier; multiplier = add(tmp, "1"); free(tmp); tmp = mult(multiplier, n2); } while (!(ret = isBigger2(tmp, n1, strlen(tmp), portion))); if (!strncmp(tmp, n1, portion)) { free(tmp); return multiplier; } free(tmp); tmp = substract(multiplier, "1"); free(multiplier); if (!strcmp(tmp, "0") && portion + 1 <= strlen(n1)) { free(tmp); return getDivider(portion + 1, n1, n2); } return tmp; }
bignum bignum::mod_inverse_of(const bignum& mod)const { pair<bignum, bignum> t = make_pair<bignum, bignum>(0x00, 0x01U); pair<bits_value, bits_value> r(mod.value_, value_); while(r.second.any()) { auto d = bits_divide(r.first, r.second); r.first = r.second; r.second = d.second; //t.first = t.second, t.second = first - second*d.quotient auto transit = t.second; t.second *= bignum(move(d.first)); t.first -= t.second; t.second = t.first; t.first = move(transit); } if(r.first.test(0) && r.first.count() == 1) { if(t.first.sign_) t.first.value_ = substract(mod.value_, t.first.value_); t.first.sign_ = sign_; return move(t.first); } throw_with_nested(coprime_error("given two nums are not co-prime")); }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); connect(ui->clear,SIGNAL(released()), this,SLOT(clear())); connect(ui->add,SIGNAL(released()), this,SLOT(add())); connect(ui->sub,SIGNAL(released()),this,SLOT(substract())); connect(ui->mul,SIGNAL(released()),this,SLOT(multiply())); connect(ui->div,SIGNAL(released()),this,SLOT(divide())); connect(ui->push_but_0,SIGNAL(released()),this,SLOT(zero())); connect(ui->push_but_1,SIGNAL(released()),this,SLOT(one())); connect(ui->push_but_2,SIGNAL(released()),this,SLOT(two())); connect(ui->push_but_3,SIGNAL(released()),this,SLOT(tree())); connect(ui->push_but_4,SIGNAL(released()),this,SLOT(four())); connect(ui->push_but_5,SIGNAL(released()),this,SLOT(five())); connect(ui->push_but_6,SIGNAL(released()),this,SLOT(six())); connect(ui->push_but_7,SIGNAL(released()),this,SLOT(seven())); connect(ui->push_but_8,SIGNAL(released()),this,SLOT(eight())); connect(ui->push_but_9,SIGNAL(released()),this,SLOT(nine())); connect(ui->equal,SIGNAL(released()),this,SLOT(equal())); connect(ui->point,SIGNAL(released()),this,SLOT(point())); connect(ui->convertingto8,SIGNAL(released()),this,SLOT(converting8())); connect(ui->point,SIGNAL(released()),this,SLOT(converting10())); }
/** * Remove one given item */ bool ItemStorage::remove(int item) { for (int i=0; i<slot_number; i++) { if (storage[i].item == item) { substract(i, 1); return true; } } return false; }
int main() { int tab[10]; int *point=tab; getValues(point); printf("Wynik: %d\n",substract(point)); }
main() { int a,b,c; a=10; b=23; c=add(a,b); printf("%d",c); c=substract(a,b); printf("%d",c); }
bool ScienceTheft::play(Player* owner, Player* opponent){ if(!substract(owner)){ return false; } int stolenScience = std::min(opponent->getScience(), 6); owner->setScience(owner->getScience() + stolenScience); opponent->setScience(opponent->getScience() - stolenScience); return true; }
ItemStack MenuItemStorage::click(InputState * input) { ItemStack item; drag_prev_slot = slotOver(input->mouse); if( drag_prev_slot > -1) { item = storage[drag_prev_slot]; if( input->pressing[SHIFT]) { item.quantity = 1; } substract( drag_prev_slot, item.quantity); return item; } else { item.item = 0; item.quantity = 0; return item; } }
int main() { printf("Hello world!\n"); memset(a,48,10); memset(b,48,10); scanf("%s %s",a,b); reverse(a,strlen(a)); // printf("After Reverse a=%s\n",a); reverse(b,strlen(b)); //printf("After Reverse b=%s\n",b); len=strlen(a); // a[len]=48; substract(); reverse(a,len); printf("%s",a); return 0; }
char *substract(const char *n1, const char *n2) { int size1, size2, ori; char *ret; if (!n1 || !n2) return strdup("0"); size1 = strlen(n1); size2 = strlen(n2); switch (check_biggest(size1, size2, n1, n2)) { case 1: return substract(n2, n1); case 2: return strdup("0"); default: break; } if (!(ret = malloc(sizeof(*ret) * (size1 + 1)))) { return 0; } memset(ret, '0', size1); ret[size1] = 0; ori = size1; --size1; --size2; while (size2 >= 0) { ret[size1] += (n1[size1] - '0') - (n2[size2] - '0'); if (ret[size1] < '0') { ret[size1 - 1] -= 1; ret[size1] += 10; } --size1; --size2; } while (size1 >= 0) { ret[size1] += (n1[size1] - '0'); --size1; } while (ret[++size1] == '0'); if (size1) memmove(ret, ret + size1, ori - size1 + 1); return ret; }
/** * Compute an addition or a substraction of polynomial * * @param poly1 The first polynomial * @param poly2 The second polynomial * @param operation Type of computation * @return Result of the computation */ polynomial addSubPoly(polynomial poly1, polynomial poly2, int operation) { // We work on dev form if (!poly1 || !poly2 || !poly1->dev || !poly2->dev) return NULL; list firstPoly = poly1->dev; list secondPoly = poly2->dev; polynomial newPoly = malloc(sizeof (polynomialElem)); while (firstPoly || secondPoly) { /** * We try to get the value of the exponent of the monomial. * If the monomial is not defined (we are at the end of the polynomial) * we set the exponent to a infinit value so that the monomial of the * other polynomial will automatically be added/substracted at the end * of the new polynomial. */ int firstExponent = firstPoly ? firstPoly->exponent : INT_MAX; int secondExponent = secondPoly ? secondPoly->exponent : INT_MAX; if (firstExponent < secondExponent) { addNode(newPoly, firstPoly->number, firstPoly->exponent, DEV_FORM); firstPoly = firstPoly->succ; } else if (secondExponent < firstExponent) { complexNumber tmpCplx = secondPoly->number; if (operation == SUB_OP) { tmpCplx.real = -getRealPart(secondPoly->number); tmpCplx.imaginary = getImaginaryPart(secondPoly->number); } addNode(newPoly, tmpCplx, secondPoly->exponent, DEV_FORM); secondPoly = secondPoly->succ; } else { if (operation == ADD_OP) addNode(newPoly, add(firstPoly->number, secondPoly->number), firstPoly->exponent, DEV_FORM); else addNode(newPoly, substract(firstPoly->number, secondPoly->number), firstPoly->exponent, DEV_FORM); firstPoly = firstPoly->succ; secondPoly = secondPoly->succ; } } return newPoly; }
char *modulo(const char *n1, const char *n2) { int size1, size2, sup; char *tmp, *tmp2, *multi; if (!n1 || !n2) return 0; if (!strcmp(n2, "0")) { return strdup("null"); } if (!strcmp(n2, "1")) { return strdup("0"); } size1 = strlen(n1); size2 = strlen(n2); if (size1 < size2) { return strdup(n1); } if (!strcmp(n1, n2)) { return strdup("0"); } tmp = strdup(n1); while (strcmp(tmp, "0") && isBigger2(tmp, n2, size1, size2)) { sup = getSuperior(size1, size2, tmp, n2); multi = getDivider(sup, tmp, n2); tmp2 = mult(multi, n2); free(multi); multi = getSubstractNumber(tmp, tmp2); free(tmp2); tmp2 = multi; multi = substract(tmp, tmp2); free(tmp); free(tmp2); tmp = multi; size1 = strlen(tmp); if (!strcmp(tmp, n2)) { free(tmp); return strdup("0"); } } return tmp; }
//Parse and translate a Math Expression void expression(){ if (isAddop(look)) { emitln("xor\t%eax,%eax"); //unary - or + so first operand is zero }else{ term(); } while (isAddop(look)) { emitln("push\t%eax"); //push eax to top of stack switch (look) { case '+': add(); break; case '-': substract(); break; default: expected("Addop"); break; } } }
int divide(char * a,int al ,char * b ,int bl){ //written division a/b - whitout result : only testing the divisibility int i; for(i=0;i<al;i++) todiv[i+1]=a[i]; todiv[0]=al; for(i=0;i<bl;i++) divby[i+al-bl+1]=b[i]; for(i=1;i<=al-bl;i++) divby[i]=0; divby[0]=al; while(1){ while(cmp(divby,todiv)>0) if(divby[0]>bl)div10(divby); else return 0; while(cmp(todiv,divby)>=0) substract(todiv,divby); if(todiv[0]==0)return 1; } }
bool Interpreter::assign() { if (lookIsAddop()) { currentStatement->createRightChild(new Literal(MyVariant(NUMBER, new real_type(0)))); } else { if (!term()) return false; } while (look!='\0' && look!=')' && look!=',') { if (look == '+') { if (!add()) return false; } else if (look =='-') { if (!substract()) return false; } else { reportExpected("Addop"); return false; } } }
void NobracketString::calculating(){ bool havesametype=false; //check for mutipositio int temporarySize=0; if(op.size()==0){ }else{ for(int i = 0;i<=op.size();++i){ //check if op contains '*' if(temporarySize != op.size()){ i = 0; } temporarySize= op.size(); if(op[i]=='/'){ if(i==0){ divide(somenumbs[0],type[0],somenumbs[1],type[1]); if(isReturnOneNumb){ //if the answer == is return one value example: log_3:4; somenumbs[i]=opAnswer; //set the element i to the opAnser, somenumbs.erase(somenumbs.begin()+1); //erase the second element op.erase(op.begin()); //erase the '*' }else{ ////cout<<"the '*' sign in the index 0 and the answer return more then one value"<<endl; } }else{ divide(somenumbs[i],type[i],somenumbs[i+1],type[i+1]); if(isReturnOneNumb){ //if the answer == is return one value example: log_3:4; somenumbs[i]=opAnswer; //set the element i to the opAnser, somenumbs.erase(somenumbs.begin()+(i+1)); //erase the second element op.erase(op.begin()+(i)); //erase the '*' // cout<<"the mutip() get answer is now "<<somenumbs[i]<<endl; // cout<<"im in the calculating function delect '*' sign DOES NOT in the index 0"<<endl; } else{ } } if(op[i]=='*'){ if(i==0){ Multip(somenumbs[0],type[0],somenumbs[1],type[1]); //do the mulip() if(isReturnOneNumb){ //if the answer == is return one value example: log_3:4; somenumbs[i]=opAnswer; //set the element i to the opAnser, somenumbs.erase(somenumbs.begin()+1); //erase the second element op.erase(op.begin()); //erase the '*' // } /* * for 3*sqrt:3+7*sqrt:3 this case; */ else{ //cout<<"the '*' sign in the index 0 and the answer return more then one value"<<endl; } // if the answer return more then one value, example 5*log_3:4; // somenumbs[i]=opAnswer; // somenumbs.erase(somenumbs.begin()+1); //erase the second element // op.erase(op.begin()); //do the mulitify everything as it is. } else{ //cout<<"do the mulitify."<<endl; Multip(somenumbs[i],type[i],somenumbs[i+1],type[i+1]); if(isReturnOneNumb){ //if the answer == is return one value example: log_3:4; somenumbs[i]=opAnswer; //set the element i to the opAnser, somenumbs.erase(somenumbs.begin()+(i+1)); //erase the second element op.erase(op.begin()+(i)); //erase the '*' // } else{} // if the answer return more then one value, example 5*log_3:4; //keep everything as it is. } } else{} //if(op[i]!='*', do nothing; //if(temporarySize != op.size()){ // i = 0; //} } //end of checking '*' } for(int i=0;type.size()-1>=somenumbs.size();i++){ type.pop_back(); } int tempSize=0; for(int i=0;i<op.size();i++){ //start to check if they have the same type; ad do the calculation for(int j=i+1;j<op.size()+1;j++) { tempSize=op.size(); if((type[i]==type[j]&&op[j]=='*')||(type[i]==type[j]&&op[i]=='*')){ //if the op is a *, skip //do nothing; } else if(type[i]==type[j]&&op[j-1]!='*'&&op[j-1]!='*'){ //if it has same type, and op does not have *,check for operator havesametype = true; if(op[j-1]=='+') { //only have two case +,- add(somenumbs[j],type[j],somenumbs[i],type[i]); if(isReturnOneNumb) { somenumbs[i]=opAnswer; if(somenumbs.size()==2&&type.size()==2&&type[1]!=type[0])//set the element i to the opAnser, { isReturnOneNumb=false; havesametype = false; }else{ somenumbs.erase(somenumbs.begin()+(j)); //erase the second element type.erase(type.begin()+j); op.erase(op.begin()+(j-1)); //erase the op } } else { //don't change anything. } // here need to do something with vectors somenumb and type // 3 + 7 = 10, 10 will replace 3 in somenumb vector and delete 7 and + from somenumb and type; // log_3:8 + log_3:7 will return as it is, so the vectors does not change, keep as it is. } else //containts "-"l { substract(somenumbs[j],type[j],somenumbs[i],type[i]); if(isReturnOneNumb) { somenumbs[i]=opAnswer; //set the element i to the opAnser, somenumbs.erase(somenumbs.begin()+(j)); //erase the second element op.erase(op.begin()+(j-1)); //erase the op } else { //don't change anything. } } } else if((type[i]=="frac"&&type[j]=="int") || (type[j]=="frac"&&type[i]=="int")) { // handle one numb is fraction, one numb is integer havesametype =true; if(op[j-1]=='+') { //only have two case +,- add(somenumbs[j],"frac",somenumbs[i],"frac"); if(isReturnOneNumb) { somenumbs[i]=opAnswer; //set the element i to the opAnser, somenumbs.erase(somenumbs.begin()+(j)); //erase the second element op.erase(op.begin()+(j-1)); //erase the op } else { //don't change anything. } } else { substract(somenumbs[j],"frac",somenumbs[i],"frac"); if(isReturnOneNumb) { somenumbs[i]=opAnswer; //set the element i to the opAnser, somenumbs.erase(somenumbs.begin()+(j)); //erase the second element op.erase(op.begin()+(j-1)); //erase the op } else { //don't change anything. } } } //check continue comparing the next type[i+1]; if(tempSize != op.size()){ j=0; } //after loop if we cannot find the same type; }//end of the int j loop // //cout<<"end check for type here"<<j<<endl; }//end of the int i loop } }
vec3& vec3::operator-=(const vec3& other) { return substract(other); }
void pratica25exercise6(int argc, const char * argv[]) { printf("\n\nExercise 6:\n"); struct rational r = promptUserForRational(); printf("Simplified it's %d/%d\n\n",r.numerator,r.denominator); struct rational r1; struct rational r2; r1.numerator = 8; r1.denominator = 4; r2.numerator = 3; r2.denominator = 6; r1 = simplifyRational(r1); test(r1.numerator==2,"Test simplify numerator"); test(r1.denominator==1,"Test simplify denominator"); r2 = simplifyRational(r2); test(r2.numerator==1,"Test simplify numerator"); test(r2.denominator==2,"Test simplify denominator"); struct rational r3 = add(r1,r2); test(r3.numerator==5, "Check add"); test(r3.denominator==2, "Check add"); r2.numerator = -2; r3 = add(r1,r2); test(r3.numerator==1, "Check add"); test(r3.denominator==1, "Check add"); r2.numerator = -2; r3 = substract(r1,r2); test(r3.numerator==3, "Check substraction"); test(r3.denominator==1, "Check substraction"); r2.numerator = 2; r3 = substract(r1,r2); test(r3.numerator==1, "Check substraction"); test(r3.denominator==1, "Check substraction"); // 2/1 * -2/2 = -4/2 = -2/1 r2.numerator = -2; r3 = product(r1,r2); test(r3.numerator==-2, "Check substraction"); test(r3.denominator==1, "Check substraction"); // 2/1 * -2/2 = 2/1 * 2/-2 = 4/-2 = -2/1 r3 = divide(r1,r2); test(r3.numerator==-2, "Check substraction"); test(r3.denominator==1, "Check substraction"); // 2/2 * -2/6 = -4/12= -1/3 r2.numerator = -2; r1.denominator = 2; r2.denominator = 6; r3 = product(r1,r2); test(r3.numerator==-1, "Check substraction"); test(r3.denominator==3, "Check substraction"); // 2/2 * -2/6 = 2/2 * 6/-2 = 12/-4= -3/1 r2.numerator = -2; r1.denominator = 2; r2.denominator = 6; r3 = divide(r1,r2); test(r3.numerator==-3, "Check substraction"); test(r3.denominator==1, "Check substraction"); }
void do_substract(const char *n, const char *n2) { char *s = substract(n, n2); printf("%s - %s = %s\n", n, n2, s); free(s); }
char *divide(const char *n1, const char *n2) { int size1, size2, pos = 0, sup, x, tmp_size, old_size; char *ret, *tmp, *tmp2, *multi; if (!n1 || !n2) return 0; if (!strcmp(n2, "0")) { return strdup("null"); } if (!strcmp(n2, "1")) { return strdup(n1); } size1 = strlen(n1); size2 = strlen(n2); if (size1 < size2) { return strdup("0"); } if (!strcmp(n1, n2)) { return strdup("1"); } ret = malloc(sizeof(*ret) * (size1 + 2)); memset(ret, 0, size1 + 2 * sizeof(*ret)); tmp = strdup(n1); while (strcmp(tmp, "0") && isBigger2(tmp, n2, size1, size2)) { sup = getSuperior(size1, size2, tmp, n2); multi = getDivider(sup, tmp, n2); x = 0; while (multi[x]) ret[pos++] = multi[x++]; tmp2 = mult(multi, n2); tmp_size = strlen(tmp2) - 1; free(multi); multi = getSubstractNumber(tmp, tmp2); free(tmp2); tmp2 = multi; multi = substract(tmp, tmp2); sup = strlen(multi); old_size = size1; x = 0; while (x++ < old_size - sup - size2 - tmp_size) { ret[pos++] = '0'; } free(tmp); free(tmp2); tmp = multi; size1 = strlen(tmp); } free(tmp); tmp = mult(ret, n2); sup = strlen(n1) - strlen(tmp); while (sup-- > 0) ret[pos++] = '0'; free(tmp); --pos; while (pos >= 0) { if (ret[pos] > '9') { if (!pos) { memcpy(ret + 1, ret, size1 + 1); ret[0] = '0'; pos += 1; } ret[pos - 1] += 1; ret[pos] -= 10; } --pos; } if (!ret[0]) ret[0] = '0'; return ret; }
int main() { int flag = 0; //To decide when to quit the application int command;//response on what user wants to do int counter; //size of array struct customer list[10]; list[0].age = 69; strcpy(list[0].name,"Nick"); list[0].info.retire = 4; list[1].age = 14; strcpy(list[1].name,"Matt"); strcpy (list[1].info.array, "Burlingame"); list[2].age = 30; strcpy(list[2].name,"Sean"); list[2].info.salary = 3000; printf("Welcome to Yuya's Restaurant what would you like to do?\n\n"); printf("Type 1 to add data for a person\n"); printf("Type 2 to eliminate an entry of a person\n"); printf("Type 3 to show all list\n"); printf("Type 4 to quit\n"); printf("----------------------------\n\n\n"); counter = 3;//take age of array in the group while (flag == 0) { scanf("%d", &command); // read in the user input if (command == 1)//add one entry { if (counter < 10){//run while under 10 list add(list, &counter); } else if (counter >= 10) { printf("Que is full."); // if the que is up to 10, do not add to list } printf("\n\nWhat would you like to do?\n"); } else if (command == 2)//delete one of the list { substract(list, &counter); printf("\n\nWhat would you like to do?\n"); } else if (command == 3)//show all array { stats(list, counter); printf("\n\nWhat would you like to do?\n"); } else if (command == 4){ //quit flag = 1; } } return 0; }
descriptor34::descriptor34(int n_maximum, int l_maximum, double j_maximum, double r_cut_in) { n_max = n_maximum; l_max = l_maximum; r_cut = r_cut_in; j_max = j_maximum; q = new radial_function[n_max + 1]; for (int i = 1; i <= n_max; i = i + 1){ q[i].n = n_max; q[i].w = new double[n_max + 1]; } factorial = new double[(n_max + l_max + lrint(2 * j_maximum)) * 10 + 11]; factorial[0] = 1; for (int i = 1; i <= (n_max + l_max + lrint(2 * j_maximum)) * 10 + 10; i = i + 1){ factorial[i] = factorial[i - 1] * i; } double_factorial = new double [(n_max + l_max + lrint(2 * j_maximum)) * 10 + 11]; double_factorial[0] = 1; double_factorial[1] = 1; for (int i = 2; i <= (n_max + l_max + lrint(2 * j_maximum) ) * 10 + 10; i = i + 1){ double_factorial[i] = double_factorial[i - 2] * i; } for (int i = 1; i <= n_max; i = i + 1){ for (int j = 1; j <= n_max; j = j + 1){ if (i == j) q[i].w[j] = 1; else q[i].w[j] = 0; } } radial_function z; z.n = n_max; z.w = new double[n_max + 1]; double k; for (int i = 1; i <= n_max; i = i + 1){ for (int j = 1; j < i; j = j + 1){ k = dot_product(q[i], q[j]) / dot_product(q[j], q[j]); z = mul(q[j], k); q[i] = substract(q[i], z); } k = dot_product(q[i], q[i]); q[i] = mul(q[i], 1/sqrt(k)); } spherical_coef = new complex**[n_max + 1]; for (int i = 1; i <= n_max; i = i + 1){ spherical_coef[i] = new complex*[l_max + 1]; } for (int i = 1; i <= n_max; i = i + 1){ for (int j = 0; j <= l_max; j = j + 1){ spherical_coef[i][j] = new complex[2 * l_max + 1]; spherical_coef[i][j] = spherical_coef[i][j] + l_max; } } hyperspherical_coef = new complex**[lrint(j_maximum * 2) + 1]; for (int i = 0; i <= lrint(j_maximum * 2); i = i + 1){ hyperspherical_coef[i] = new complex*[2 * lrint(j_maximum * 2) + 1]; hyperspherical_coef[i] = hyperspherical_coef[i] + lrint(j_maximum * 2); } for (int i = 0; i <= lrint(j_maximum * 2); i = i + 1){ for (int j = -i; j <= i; j = j + 1){ hyperspherical_coef[i][j] = new complex[2 * lrint(j_maximum * 2) + 1]; hyperspherical_coef[i][j] = hyperspherical_coef[i][j] + lrint(j_maximum * 2); } } /*FILE *f = fopen("input.txt", "r"); int num_atoms; fscanf(f, "%d", &num_atoms); vector *vectors; vectors = new vector[num_atoms + 1]; for (int i = 1; i <= num_atoms; i = i + 1){ fscanf(f, "%lf %lf %lf", &vectors[i].x, &vectors[i].y, &vectors[i].z); } fclose(f); FILE *g = fopen("output.txt", "w"); calculate_and_write_power_spectrum(num_atoms, vectors, g); calculate_and_write_bispectrum(num_atoms, vectors, g); fclose(g); */ /* complex co = integral(1, 1, -1,1, 1, -1); co.print(); */ }
void ScalarOperatorNode::run(ExecutionNode* previous) { m_previousNode= previous; if(nullptr != m_internalNode) { m_internalNode->run(this); } if(nullptr != previous) { auto previousResult= previous->getResult(); if(nullptr != previousResult) { ExecutionNode* internal= m_internalNode; if(nullptr != internal) { while(nullptr != internal->getNextNode()) { internal= internal->getNextNode(); } Result* internalResult= internal->getResult(); m_result->setPrevious(internalResult); if(nullptr != m_internalNode->getResult()) { m_internalNode->getResult()->setPrevious(previousResult); } switch(m_arithmeticOperator) { case Die::PLUS: m_scalarResult->setValue(add(previousResult->getResult(Result::SCALAR).toReal(), internalResult->getResult(Result::SCALAR).toReal())); break; case Die::MINUS: m_scalarResult->setValue(substract(previousResult->getResult(Result::SCALAR).toReal(), internalResult->getResult(Result::SCALAR).toReal())); break; case Die::MULTIPLICATION: m_scalarResult->setValue(multiple(previousResult->getResult(Result::SCALAR).toReal(), internalResult->getResult(Result::SCALAR).toReal())); break; case Die::DIVIDE: m_scalarResult->setValue(divide(previousResult->getResult(Result::SCALAR).toReal(), internalResult->getResult(Result::SCALAR).toReal())); break; case Die::INTEGER_DIVIDE: m_scalarResult->setValue(static_cast<int>(divide(previousResult->getResult(Result::SCALAR).toReal(), internalResult->getResult(Result::SCALAR).toReal()))); break; case Die::POW: m_scalarResult->setValue(pow(previousResult->getResult(Result::SCALAR).toReal(), internalResult->getResult(Result::SCALAR).toReal())); break; } } if(nullptr != m_nextNode) { m_nextNode->run(this); } } } }
int main() { slist *a = NULL; slist *b = NULL; int negative = 0; int first_valid_digit = 0; int first = 1; char c; while ((c = getchar()) != '\n') { if ((c == '-') && (negative == 0) && first) negative = 1; else { unsigned int x = c - '0'; if (x >= 1 && x <= 9) { first_valid_digit = 1; a = insert(a, x); } else if (x == 0 && first_valid_digit) { a = insert(a, x); } } first = 0; } if (negative && length(a)) a = push_back(a, -1); negative = 0; first_valid_digit = 0; first = 1; while ((c = getchar()) != '\n') { if ((c == '-') && (negative == 0) && first) negative = 1; else { unsigned int x = c - '0'; if (x >= 0 && x <= 9) { first_valid_digit = 1; b = insert(b, x); } else if (x == 0 && first_valid_digit) { b = insert(b, x); } } } if (negative && length(b)) b = push_back(b, -1); print(a); print(b); slist *sum = add(a, b); slist *diff = substract(a, b); print(sum); print(diff); printf("Sum:\n"); print_num(sum); printf("\n"); printf("Diff:\n"); print_num(diff); printf("\n"); cleanup(&a); cleanup(&b); cleanup(&sum); cleanup(&diff); return 0; }