/** @brief ハウスホルダー・ベクトルへの変換. @details h[0]=0; ...; h[k-1]=0; h[k]=-s*xi; h[k+1]=x[k+1]; ...; h[n-1]=x[n-1]; @param[in] h 初期化済みのベクトル.サイズはn. @param[in] x 初期化済みのベクトル.サイズはn. @param[in] n ベクトルのサイズ. @param[in] k 第k要素が基準. @param[out] h ハウスホルダー・ベクトル. */ void rhouseholder_vec(int n, int k, rmulti **h, rmulti *alpha, rmulti **x) { int p0,p1,prec; rmulti *eta=NULL,*zeta=NULL,*xi=NULL,*axk=NULL; // allocate p0=rget_prec(alpha); p1=rvec_get_prec_max(n,h); prec=MAX2(p0,p1); eta=rallocate_prec(prec); zeta=rallocate_prec(prec); xi=rallocate_prec(prec); axk=rallocate_prec(prec); //----------- norm rvec_sum_pow2(xi,n-k-1,&x[k+1]); // xi=sum(abs(x((k+1):end)).^2); rmul(axk,x[k],x[k]); // axk=|x[k]|^2 radd(eta,axk,xi); // eta=|x[k]|^2+... rsqrt(axk,axk); // axk=|x[k]| rsqrt(eta,eta); // eta=sqrt(|x[k]|^2+...) if(req_d(eta,0)){rsub(xi,eta,axk);} // xi=eta-|x(k)| else{ // xi=xi/(|x(k)|+eta) radd(zeta,axk,eta); rdiv(xi,xi,zeta); } //----------- h rvec_set_zeros(k,h); rvec_copy(n-k-1,&h[k+1],&x[k+1]); // h((k+1):end)=x((k+1):end); if(ris_zero(x[k])){ rcopy(h[k],xi); rneg(h[k],h[k]); // h[k]=-xi }else{ rdiv(zeta,xi,axk); rneg(zeta,zeta); // zeta=-xi/axk; rmul(h[k],x[k],zeta); // h[k]=zeta*x[k]; } //----------- alpha if(req_d(xi,0) || req_d(eta,0)){ rset_d(alpha,0); }else{ rmul(alpha,xi,eta); // alpha=1/(xi*eta) rinv(alpha,alpha); } // free eta=rfree(eta); zeta=rfree(zeta); xi=rfree(xi); axk=rfree(axk); }
int btree::radd(btnode* &pn, float d) { if(pn != NULL) if( pn->data > d ) rval = radd(pn->ltree, d); else if( pn->data < d ) rval = radd(pn->rtree, d); else // same value rval = 0; else // add { rval = 1; pn = new btnode(d); } return rval; }
IExprNode* radd(const std::vector<Token>& tokens, int &curToken, IExprNode* left) { if (curToken == tokens.size()) return left; const Token& t = tokens[curToken]; if (t.type == Token::TT_notation && (t.value == "+" || t.value == "-")) { ++curToken; IExprNode *opNode = new ExprNode_BinaryOp(t.value, left, mul(tokens, curToken)); return radd(tokens, curToken, opNode); } else return left; }
string multiply(string num1, string num2) { string product; reverse(num1); reverse(num2); for (int i = 0, endi = num2.size(); i < endi; ++i) { string temp = rmultiplyDigit(num1, num2[i]); product = product.substr(0, i) + radd(product.substr(i), temp); } reverse(product); clean(product); return product; }
main( int argc, char* argv[] ) { char *host; int r; if(argc < 2) { printf("usage: %s server_host\n", argv[0]); exit(1); } host = argv[1]; r = radd( host, 3, 4 ); printf ("3 + 4 = %d\n", r); exit(0); }
int StackAdd(void) { if(curstksize < 2){ return 1; } stack[0] = radd(stack[1], stack[0]); for(int i = 1; i < curstksize - 1; ++i){ stack[i] = stack[i + 1]; } --curstksize; return 0; }
void riep_dhToda_TN(int m, int M, rmulti **A, int LDA, rmulti **Q, int LDQ, rmulti **E, rmulti **lambda, rmulti **c, int debug) { int prec=0,k=0,n=0,f_size=0,n_size=0,*Q0_size=NULL,*E0_size=NULL,LDQ1; rmulti *a=NULL,**f=NULL,***Q0=NULL,***E0=NULL,**sigma=NULL,**Q1=NULL,**E1=NULL; // init n_size=(M+1)*(m-1)+2*M; // precision prec=rmat_get_prec_max(m,m,A,LDA); // allocate if(Q==NULL) { LDQ1=m; Q1=rmat_allocate_prec(m,M,prec); } else { LDQ1=LDQ; Q1=Q; } if(E==NULL) { E1=rvec_allocate_prec(m,prec); } else { E1=E; } sigma=rvec_allocate_prec(m,prec); a=rallocate_prec(prec); Q0_size=ivec_allocate(m); Q0=malloc(m*sizeof(rmulti**)); for(k=0; k<m; k++) { Q0_size[k]=n_size-k*(M+1); Q0[k]=rvec_allocate_prec(Q0_size[k],prec); } E0_size=ivec_allocate(m); E0=malloc(m*sizeof(rmulti**)); for(k=0; k<m; k++) { E0_size[k]=n_size-(k+1)*(M+1)+1; E0[k]=rvec_allocate_prec(E0_size[k],prec); } f_size=Q0_size[0]+1; f=rvec_allocate_prec(f_size,prec); // generate sigma[n] rinv_d(a,M); rvec_pow_r(m,sigma,lambda,a); // generate f[n] for(n=0; n<f_size; n++) { rset_d(f[n],0); for(k=0; k<m; k++) { rpow_si(a,sigma[k],n); // a=(sigma[i])^n radd_mul(f[n],c[k],a); // f[i]=f[i]+c[i]*(sigma[i])^n } } // Q[n][0]=f[n+1]/f[n] for(n=0; n<Q0_size[0]; n++) { if(n+1<f_size) { rdiv(Q0[0][n],f[n+1],f[n]); } else { rset_nan(Q0[0][n]); } } // E[0][n]=Q[0][n+M]-Q[0][n]; k=0; for(n=0; n<E0_size[k]; n++) { if(n+M<Q0_size[k] && n<Q0_size[k]) { rsub(E0[k][n],Q0[k][n+M],Q0[k][n]); } else { rset_nan(E0[k][n]); } } // loop for QE-table for(k=1; k<m; k++) { // Q[k][n]=(E[k-1][n+1]*Q[k-1][n+M])/E[k-1][n]; for(n=0; n<Q0_size[k]; n++) { rdiv(a,E0[k-1][n+1],E0[k-1][n]); rmul(Q0[k][n],a,Q0[k-1][n+M]); } // E[k][n]=Q[k][n+M]-Q[k][n]+E[k-1][n+1] for(n=0; n<E0_size[k]; n++) { rsub(a,Q0[k][n+M],Q0[k][n]); radd(E0[k][n],a,E0[k-1][n+1]); } } // debug if(debug>0) { printf("Q=\n"); for(n=0; n<n_size; n++) { for(k=0; k<m; k++) { if(n<Q0_size[k]) { mpfr_printf("%.3Re ",Q0[k][n]); } } printf("\n"); } printf("E=\n"); for(n=0; n<n_size; n++) { for(k=0; k<m; k++) { if(n<E0_size[k]) { mpfr_printf("%.3Re ",E0[k][n]); } } printf("\n"); } } // generate vector E for(k=0; k<m; k++) { rcopy(E1[k],E0[k][0]); } // generate matrix Q for(n=0; n<M; n++) { for(k=0; k<m; k++) { rcopy(MAT(Q1,k,n,LDQ1),Q0[k][n]); } } // genrate matrix A if(A!=NULL) { riep_dhToda_QE_to_A(m,M,A,LDA,Q1,LDQ1,E1,debug); } // done if(Q==NULL) { Q1=rmat_free(LDQ1,M,Q1); } else { Q1=NULL; } if(E==NULL) { E1=rvec_free(m,E1); } else { E1=NULL; } a=rfree(a); f=rvec_free(f_size,f); sigma=rvec_free(m,sigma); for(k=0; k<m; k++) { Q0[k]=rvec_free(Q0_size[k],Q0[k]); } free(Q0); Q0=NULL; for(k=0; k<m; k++) { E0[k]=rvec_free(E0_size[k],E0[k]); } free(E0); E0=NULL; Q0_size=ivec_free(Q0_size); E0_size=ivec_free(E0_size); return; }
int main() { Ins *i1; unsigned long long tm, rm, cnt; RMap mend; int reg[NIReg], val[NIReg+1]; int t, i, r, nr; tmp = (Tmp[Tmp0+NIReg]){{{0}}}; for (t=0; t<Tmp0+NIReg; t++) if (t >= Tmp0) { tmp[t].cls = Kw; tmp[t].hint.r = -1; tmp[t].hint.m = 0; tmp[t].slot = -1; sprintf(tmp[t].name, "tmp%d", t-Tmp0+1); } bsinit_(mbeg.b, Tmp0+NIReg); bsinit_(mend.b, Tmp0+NIReg); cnt = 0; for (tm = 0; tm < 1ull << (2*NIReg); tm++) { mbeg.n = 0; bszero(mbeg.b); ip = ins; /* find what temporaries are in copy and * wether or not they are in register */ for (t=0; t<NIReg; t++) switch ((tm >> (2*t)) & 3) { case 0: /* not in copy, not in reg */ break; case 1: /* not in copy, in reg */ radd(&mbeg, Tmp0+t, t+1); break; case 2: /* in copy, not in reg */ *ip++ = (Ins){OCopy, TMP(Tmp0+t), {R, R}, Kw}; break; case 3: /* in copy, in reg */ *ip++ = (Ins){OCopy, TMP(Tmp0+t), {R, R}, Kw}; radd(&mbeg, Tmp0+t, t+1); break; } if (ip == ins) /* cancel if the parallel move * is empty */ goto Nxt; /* find registers for temporaries * in mbeg */ nr = ip - ins; rm = (1ull << (nr+1)) - 1; for (i=0; i<nr; i++) reg[i] = i+1; for (;;) { /* set registers on copies */ for (i=0, i1=ins; i1<ip; i1++, i++) i1->arg[0] = TMP(reg[i]); /* compile the parallel move */ rcopy(&mend, &mbeg); dopm(&dummyb, ip-1, &mend); cnt++; /* check that mend contain mappings for * source registers and does not map any * assigned temporary, then check that * all temporaries in mend are mapped in * mbeg and not used in the copy */ for (i1=ins; i1<ip; i1++) { r = i1->arg[0].val; assert(rfree(&mend, r) == r); t = i1->to.val; assert(!bshas(mend.b, t)); } for (i=0; i<mend.n; i++) { t = mend.t[i]; assert(bshas(mbeg.b, t)); t -= Tmp0; assert(((tm >> (2*t)) & 3) == 1); } /* execute the code generated and check * that all assigned temporaries got their * value, and that all live variables's * content got preserved */ for (i=1; i<=NIReg; i++) val[i] = i; iexec(val); for (i1=ins; i1<ip; i1++) { t = i1->to.val; r = rfind(&mbeg, t); if (r != -1) assert(val[r] == i1->arg[0].val); } for (i=0; i<mend.n; i++) { t = mend.t[i]; r = mend.r[i]; assert(val[t-Tmp0+1] == r); } /* find the next register assignment */ i = nr - 1; for (;;) { r = reg[i]; rm &= ~(1ull<<r); do r++; while (r <= NIReg && (rm & (1ull<<r))); if (r == NIReg+1) { if (i == 0) goto Nxt; i--; } else { rm |= (1ull<<r); reg[i++] = r; break; } } for (; i<nr; i++) for (r=1; r<=NIReg; r++) if (!(rm & (1ull<<r))) { rm |= (1ull<<r); reg[i] = r; break; } } Nxt: freeall(); } printf("%llu tests successful!\n", cnt); exit(0); }
IExprNode* add(const std::vector<Token>& tokens, int &curToken) { IExprNode *left = mul(tokens, curToken); return radd(tokens, curToken, left); }
int btree::add(float d) { return radd(entry, d); }