template <class T> complex<T> R2q2g_qmqppm_LT (const eval_param<T>& ep, const mass_param_coll& mpc){ // {{qm, qp, p, m}, LT} #if _VERBOSE _MESSAGE("R2q2g : qmqppm LT"); #endif return( (complex<T>(0,-1)*pow(SPA(1,4),2)*SPA(2,4))/(complex<T>(2,0)*SPA(1,2)*SPA(2,3)* SPA(3,4)) ); }
static F2(jtpdtspvv){A x;D*av,s,t,*wv,z;I i,*u,*u0,*uu,*v,*v0,*vv;P*ap,*wp; RZ(a&&w); ap=PAV(a); x=SPA(ap,i); u=u0=AV(x); uu=u+AN(x); x=SPA(ap,x); av=DAV(x); wp=PAV(w); x=SPA(wp,i); v=v0=AV(x); vv=v+AN(x); x=SPA(wp,x); wv=DAV(x); z=0.0; NAN0; while(1){ i=*u; while(i>*v&&v<vv)++v; if(v==vv)break; if(i==*v){s=av[u-u0]; t=wv[v-v0]; z+=s&&t?s*t:0; ++u; ++v; continue;} i=*v; while(i>*u&&u<uu)++u; if(u==uu)break; if(i==*u){s=av[u-u0]; t=wv[v-v0]; z+=s&&t?s*t:0; ++u; ++v; continue;} } NAN1; R scf(z); }
static F2(jtpdtspmv){A ax,b,g,x,wx,y,yi,yj,z;B*bv;I m,n,s[2],*u,*v,*yv;P*ap,*wp,*zp; RZ(a&&w); ap=PAV(a); y=SPA(ap,i); yv=AV(y); s[0]=n=*AS(y); s[1]=1; GATV(yj,INT,n,2,s); if(DENSE&AT(w)){ GATV(yi,INT,n,2,s); u=AV(yi); AR(yj)=1; v=AV(yj); DO(n, *u++=*yv++; *v++=*yv++;);
/*------------------------------------------------------------------------ * mkarp - allocate and fill in an ARP or RARP packet *------------------------------------------------------------------------ */ static struct ep * mkarp(int ifn, short type, short op, IPaddr spa, IPaddr tpa) { register struct arp *parp; struct ep *pep; pep = (struct ep *) getbuf(Net.netpool); if ((int)pep == SYSERR) return (struct ep *)SYSERR; memcpy(pep->ep_dst, nif[ifn].ni_hwb.ha_addr, EP_ALEN); pep->ep_order = ~0; pep->ep_type = type; parp = (struct arp *)pep->ep_data; parp->ar_hwtype = hs2net(AR_HARDWARE); parp->ar_prtype = hs2net(EPT_IP); parp->ar_hwlen = EP_ALEN; parp->ar_prlen = IP_ALEN; parp->ar_op = hs2net(op); memcpy(SHA(parp), nif[ifn].ni_hwa.ha_addr, EP_ALEN); memcpy(SPA(parp), &spa, IP_ALEN); memcpy(THA(parp), nif[ifn].ni_hwa.ha_addr, EP_ALEN); memcpy(TPA(parp), &tpa, IP_ALEN); return pep; }
static B jtspsscell(J jt,A w,I wf,I wcr,A*zc,A*zt){A c,t,y;B b; I cn,*cv,j,k,m,n,p,*s,tn,*tv,*u,*u0,*v,*v0;P*wp; wp=PAV(w); s=AS(w); p=3+s[wf]; y=SPA(wp,i); s=AS(y); m=s[0]; n=s[1]; u0=AV(y); u=u0+n; v0=u0+wf; v=v0+n; if(!m){*zt=*zc=mtv; R 1;} GATV(t,INT,2+2*m,1,0); tv=AV(t); tv[0]=tv[1]=0; tn=2; GATV(c,INT, 2*m,2,0); cv=AV(c); cv[0]=0; cn=0; *(1+AS(c))=2; for(j=1;j<m;++j){ b=1; for(k=0;k<wf;++k) if(u0[k]!=u[k]){ tv[tn++]=j; tv[tn++]=j; cv[1+cn]=tn-cv[cn]; if(p==tn-cv[cn]){++cv[cn]; cv[1+cn]-=2;} cn+=2; cv[cn]=tn-2; u0=u; v0=v; b=0; break; } if(b&&*v0!=*v){tv[tn++]=j; v0=v;} u+=n; v+=n; } tv[tn++]=m; tv[tn++]=m; cv[1+cn]=tn-cv[cn]; if(p==tn-cv[cn]){++cv[cn]; cv[1+cn]-=2;} cn+=2; AN(t)= *AS(t)=tn; *zt=t; /* cell divisions (row indices in y) */ AN(c)=cn; *AS(c)=cn/2; *zc=c; /* item divisions (indices in t, # of elements) */ R 1; } /* frame: all sparse; cell: 1 or more sparse, then dense */
static REPF(jtrepzdx){A p,q,x;P*wp; RZ(a&&w); if(SPARSE&AT(w)){wp=PAV(w); x=SPA(wp,e);} else x=jt->fill&&AN(jt->fill)?jt->fill:filler(w); RZ(p=repeat(ravel(rect(a)),ravel(stitch(IX(wcr?*(wf+AS(w)):1),num[-1])))); RZ(q=irs2(w,x,0L,wcr,0L,jtover)); R irs2(p,q,0L,1L,wcr+!wcr,jtfrom); } /* (dense complex) # (dense or sparse) */
static A jtcants(J jt,A a,A w,A z){A a1,q,y;B*b,*c;I*u,wr,zr;P*wp,*zp; RZ(a&&w&&z); RZ(a=grade1(a)); wr=AR(w); wp=PAV(w); a1=SPA(wp,a); zr=AR(z); zp=PAV(z); ASSERT(wr==zr,EVNONCE); RZ(b=bfi(wr,a1,1)); GA(q,B01,wr,1,0); c=BAV(q); u=AV(a); DO(wr, c[i]=b[u[i]];);
SUFFIX_TREE* ST_CreateTree(const char* str, DBL_WORD length) { SUFFIX_TREE* tree; DBL_WORD phase , extension; char repeated_extension = 0; POS pos; if(str == 0) return 0; /* Allocating the tree */ tree = malloc(sizeof(SUFFIX_TREE)); if(tree == 0) { printf("\nOut of memory.\n"); exit(0); } heap+=sizeof(SUFFIX_TREE); /* Calculating string length (with an ending $ sign) */ tree->length = length+1; ST_ERROR = length+10; /* Allocating the only real string of the tree */ tree->tree_string = malloc((tree->length+1)*sizeof(char)); if(tree->tree_string == 0) { printf("\nOut of memory.\n"); exit(0); } heap+=(tree->length+1)*sizeof(char); memcpy(tree->tree_string+sizeof(char),str,length*sizeof(char)); /* $ is considered a uniqe symbol */ tree->tree_string[tree->length] = '$'; /* Allocating the tree root node */ tree->root = create_node(0, 0, 0, 0); tree->root->suffix_link = 0; /* Initializing algorithm parameters */ extension = 2; phase = 2; /* Allocating first node, son of the root (phase 0), the longest path node */ tree->root->sons = create_node(tree->root, 1, tree->length, 1); suffixless = 0; pos.node = tree->root; pos.edge_pos = 0; /* Ukkonen's algorithm begins here */ for(; phase < tree->length; phase++) { /* Perform Single Phase Algorithm */ SPA(tree, &pos, phase, &extension, &repeated_extension); } return tree; }
int main() { int test,m,a,b,c; scanf("%d",&test); while(test--) { scanf("%d%d",&n,&m); for(int i=0;i<=n;i++) for(int j=0;j<=n;j++) dis[i][j] = MAX; int spow = 0; for(int i=0;i<m;i++) { scanf("%d%d%d",&a,&b,&c); if(dis[a][b]>c) { dis[a][b] = c; dis[b][a] = c; } } for(int i=1;i<=n;i++) { scanf("%d",&pow[i]); spow += pow[i]; } SPA(); for(int j=0;j<=spow;j++) mn[j] = MAX; mn[0] = 0; int curm = 0; int hpow = spow/2+1; int ans = MAX; /* for(int i=1;i<=n;i++) printf("%d ",mdis[i]); printf("%d\n",hpow); */ for(int i=1;i<=n;i++) { if(mdis[i]>=MAX)continue; for(int j=curm;j>=0;j--) { if(mn[j] == MAX)continue; if(mdis[i] + mn[j] < mn[j+pow[i]]) { mn[j+pow[i]] = mdis[i] + mn[j]; if(j+pow[i]>=hpow) if(mn[j+pow[i]]<ans) ans = mn[j+pow[i]]; } } curm += pow[i]; } if(ans < MAX) printf("%d\n",ans); else printf("impossible\n"); } return 0; }
template <int i1, int i2, int i3, int i4, int i5, int i6, class T> complex<T> A2q2Q2l_qmqb2mq2pqbplmlbp_eval(const eval_param<T>& ep, const mass_param_coll& masses) { const complex<T> spb56=SPB(i5,i6); const complex<T> spb46=SPB(i4,i6); const complex<T> spb43=SPB(i4,i3); const complex<T> spb42=SPB(i4,i2); const complex<T> spb34=SPB(i3,i4); const complex<T> spb32=SPB(i3,i2); const complex<T> spb31=SPB(i3,i1); const complex<T> spb23=SPB(i2,i3); const complex<T> spb21=SPB(i2,i1); const complex<T> spa56=SPA(i5,i6); const complex<T> spa34=SPA(i3,i4); const complex<T> spa24=SPA(i2,i4); const complex<T> spa23=SPA(i2,i3); const complex<T> spa15=SPA(i1,i5); const complex<T> spa13=SPA(i1,i3); const complex<T> spa12=SPA(i1,i2); const complex<T> pow2_spb46=(pow(spb46,2)); const complex<T> pow2_spb34=(pow(spb34,2)); const complex<T> pow2_spa15=(pow(spa15,2)); const complex<T> pow2_spa12=(pow(spa12,2)); const complex<T> spab_1_23_4=-(spa12*spb42)-spa13*spb43; const complex<T> s234=(spa23*spb32+spa24*spb42+spa34*spb43); const complex<T> s123=(spa12*spb21+spa13*spb31+spa23*spb32); return( ((pow2_spa15*pow2_spb34)/(s234*spa56*spab_1_23_4*spb23) - (pow2_spa12*pow2_spb46)/(s123*spa23*spab_1_23_4*spb56))*complex<T>(0,1) ); }
void process_fddi(register u_char *u, register const struct pcap_pkthdr *h, register const u_char *p) { register struct fddi_header *fh; register struct ether_arp *ea; register u_char *sea, *sha; register time_t t; u_int32_t sia; fh = (struct fddi_header *)p; ea = (struct ether_arp *)(fh + 1); if (!swapped) { bit_reverse(fh->src, 6); bit_reverse(fh->dst, 6); } if (!sanity_fddi(fh, ea, h->caplen)) return; /* Source MAC hardware ethernet address */ sea = (u_char *)fh->src; /* Source ARP ethernet address */ sha = (u_char *)SHA(ea); /* Source ARP ip address */ BCOPY(SPA(ea), &sia, 4); /* Watch for bogons */ if (isbogon(sia)) { dosyslog(LOG_INFO, "bogon", sia, sea, sha); return; } /* Watch for ethernet broadcast */ if (MEMCMP(sea, zero, 6) == 0 || MEMCMP(sea, allones, 6) == 0 || MEMCMP(sha, zero, 6) == 0 || MEMCMP(sha, allones, 6) == 0) { dosyslog(LOG_INFO, "ethernet broadcast", sia, sea, sha); return; } /* Double check ethernet addresses */ if (MEMCMP(sea, sha, 6) != 0) { dosyslog(LOG_INFO, "ethernet mismatch", sia, sea, sha); return; } /* Got a live one */ t = h->ts.tv_sec; can_checkpoint = 0; if (!ent_add(sia, sea, t, NULL)) syslog(LOG_ERR, "ent_add(%s, %s, %ld) failed", intoa(sia), e2str(sea), t); can_checkpoint = 1; }
static REPF(jtrepzsx) { A q,x,y; I c,d,j,k=-1,m,p=0,*qv,*xv,*yv; P*ap; RZ(a&&w); ap=PAV(a); x=SPA(ap,x); m=AN(x); if(!AN(SPA(ap,a)))R repzdx(ravel(x),w,wf,wcr); y=SPA(ap,i); yv=AV(y); RZ(x=cvt(INT,vec(FL,2*m,AV(x)))); xv=AV(x); if(equ(zero,SPA(ap,e))) { k=c=*(wf+AS(w)); if(!wf&&SPARSE&AT(w)) { A a,y; I m,n,q,*v; P*wp; wp=PAV(w); a=SPA(wp,a); if(AN(a)&&!*AV(a)) { y=SPA(wp,i); v=AS(y); m=v[0]; n=v[1]; v=AV(y); k=m?v[(m-1)*n]+1:0; q=0; DO(m, if(q==*v)++q; else if(q<*v) { k=q; break; } v+=n;); }
/*------------------------------------------------------------------------ * arpadd - Add a RESOLVED entry to the ARP cache * N.B. Assumes interrupts disabled *------------------------------------------------------------------------ */ struct arpentry * arpadd(struct netif *pni, struct arp *parp) { struct arpentry *pae; pae = arpalloc(); pae->ae_hwtype = parp->ar_hwtype; pae->ae_prtype = parp->ar_prtype; pae->ae_hwlen = parp->ar_hwlen; pae->ae_prlen = parp->ar_prlen; pae->ae_pni = pni; pae->ae_queue = EMPTY; memcpy(pae->ae_hwa, SHA(parp), parp->ar_hwlen); memcpy(pae->ae_pra, SPA(parp), parp->ar_prlen); pae->ae_ttl = ARP_TIMEOUT; pae->ae_state = AS_RESOLVED; return pae; }
template <class T> complex<T> A_qGGqy_mmppp_eval(const eval_param<T>& ep, const mass_param_coll& masses){ return( (complex<T>(0,-1)*pow(SPA(2,1),2))/(SPA(3,2)* SPA(5,1)*SPA(5,4)) ); }
if(i==*v){s=av[u-u0]; t=wv[v-v0]; z+=s&&t?s*t:0; ++u; ++v; continue;} i=*v; while(i>*u&&u<uu)++u; if(u==uu)break; if(i==*u){s=av[u-u0]; t=wv[v-v0]; z+=s&&t?s*t:0; ++u; ++v; continue;} } NAN1; R scf(z); } static F2(jtpdtspmv){A ax,b,g,x,wx,y,yi,yj,z;B*bv;I m,n,s[2],*u,*v,*yv;P*ap,*wp,*zp; RZ(a&&w); ap=PAV(a); y=SPA(ap,i); yv=AV(y); s[0]=n=*AS(y); s[1]=1; GATV(yj,INT,n,2,s); if(DENSE&AT(w)){ GATV(yi,INT,n,2,s); u=AV(yi); AR(yj)=1; v=AV(yj); DO(n, *u++=*yv++; *v++=*yv++;); ax=SPA(ap,x); RZ(wx=from(yj,w)); }else{ v=AV(yj); DO(n, yv++; *v++=*yv++;); wp=PAV(w); RZ(b=eps(yj,SPA(wp,i))); bv=BAV(b); AN(yj)=*AS(yj)=*s=m=bsum(n,bv); v=AV(yj); yv=AV(y); GATV(yi,INT,m,2,s); u=AV(yi); DO(n, if(*bv++){*u++=*yv++; *v++=*yv++;}else yv+=2;); RZ(ax=repeat(b,SPA(ap,x))); RZ(wx=from(indexof(SPA(wp,i),yj),SPA(wp,x))); } RZ(x=df2(yi,tymes(ax,wx),sldot(slash(ds(CPLUS))))); RZ(y=nub(yi)); RZ(g=grade1(y)); GA(z,STYPE(AT(x)),1,1,AS(a)); zp=PAV(z); SPB(zp,a,iv0); SPB(zp,e,scf(0.0));
template <class T> complex<T> A_qqGGy_mpmpp_eval(const eval_param<T>& ep, const mass_param_coll& masses){ return( (complex<T>(0,-1)*pow(SPA(1,3),2))/ (SPA(1,5)*SPA(2,5)*SPA(3,4)) ); }
void arp_print(netdissect_options *ndo, const u_char *bp, u_int length, u_int caplen) { const struct arp_pkthdr *ap; u_short pro, hrd, op, linkaddr; ap = (const struct arp_pkthdr *)bp; ND_TCHECK(*ap); hrd = HRD(ap); pro = PRO(ap); op = OP(ap); /* if its ATM then call the ATM ARP printer for Frame-relay ARP most of the fields are similar to Ethernet so overload the Ethernet Printer and set the linkaddr type for linkaddr_string() accordingly */ switch(hrd) { case ARPHRD_ATM2225: atmarp_print(ndo, bp, length, caplen); return; case ARPHRD_FRELAY: linkaddr = LINKADDR_FRELAY; break; default: linkaddr = LINKADDR_ETHER; break; } if (!ND_TTEST2(*ar_tpa(ap), PROTO_LEN(ap))) { ND_PRINT((ndo, "[|ARP]")); ND_DEFAULTPRINT((const u_char *)ap, length); return; } if (!ndo->ndo_eflag) { ND_PRINT((ndo, "ARP, ")); } /* print hardware type/len and proto type/len */ if ((pro != ETHERTYPE_IP && pro != ETHERTYPE_TRAIL) || PROTO_LEN(ap) != 4 || HRD_LEN(ap) == 0 || ndo->ndo_vflag) { ND_PRINT((ndo, "%s (len %u), %s (len %u)", tok2str(arphrd_values, "Unknown Hardware (%u)", hrd), HRD_LEN(ap), tok2str(ethertype_values, "Unknown Protocol (0x%04x)", pro), PROTO_LEN(ap))); /* don't know know about the address formats */ if (!ndo->ndo_vflag) { goto out; } } /* print operation */ printf("%s%s ", ndo->ndo_vflag ? ", " : "", tok2str(arpop_values, "Unknown (%u)", op)); switch (op) { case ARPOP_REQUEST: ND_PRINT((ndo, "who-has %s", ipaddr_string(TPA(ap)))); if (memcmp((const char *)ezero, (const char *)THA(ap), HRD_LEN(ap)) != 0) ND_PRINT((ndo, " (%s)", linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)))); ND_PRINT((ndo, " tell %s", ipaddr_string(SPA(ap)))); break; case ARPOP_REPLY: ND_PRINT((ndo, "%s is-at %s", ipaddr_string(SPA(ap)), linkaddr_string(SHA(ap), linkaddr, HRD_LEN(ap)))); break; case ARPOP_REVREQUEST: ND_PRINT((ndo, "who-is %s tell %s", linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)), linkaddr_string(SHA(ap), linkaddr, HRD_LEN(ap)))); break; case ARPOP_REVREPLY: ND_PRINT((ndo, "%s at %s", linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)), ipaddr_string(TPA(ap)))); break; case ARPOP_INVREQUEST: ND_PRINT((ndo, "who-is %s tell %s", linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)), linkaddr_string(SHA(ap), linkaddr, HRD_LEN(ap)))); break; case ARPOP_INVREPLY: ND_PRINT((ndo,"%s at %s", linkaddr_string(THA(ap), linkaddr, HRD_LEN(ap)), ipaddr_string(TPA(ap)))); break; default: ND_DEFAULTPRINT((const u_char *)ap, caplen); return; } out: ND_PRINT((ndo, ", length %u", length)); return; trunc: ND_PRINT((ndo, "[|ARP]")); }
void arp_print(register const u_char *bp, u_int length, u_int caplen) { register const struct ether_arp *ap; register const struct ether_header *eh; register u_short pro, hrd, op; ap = (struct ether_arp *)bp; if ((u_char *)(ap + 1) > snapend) { printf("[|arp]"); return; } if (length < sizeof(struct ether_arp)) { (void)printf("truncated-arp"); default_print((u_char *)ap, length); return; } pro = EXTRACT_16BITS(&ap->arp_pro); hrd = EXTRACT_16BITS(&ap->arp_hrd); op = EXTRACT_16BITS(&ap->arp_op); if ((pro != ETHERTYPE_IP && pro != ETHERTYPE_TRAIL) || ap->arp_hln != sizeof(SHA(ap)) || ap->arp_pln != sizeof(SPA(ap))) { (void)printf("arp-#%d for proto #%d (%d) hardware #%d (%d)", op, pro, ap->arp_pln, hrd, ap->arp_hln); return; } if (pro == ETHERTYPE_TRAIL) (void)printf("trailer-"); eh = (struct ether_header *)packetp; switch (op) { case ARPOP_REQUEST: (void)printf("arp who-has %s", ipaddr_string(TPA(ap))); if (memcmp((char *)ezero, (char *)THA(ap), 6) != 0) (void)printf(" (%s)", etheraddr_string(THA(ap))); (void)printf(" tell %s", ipaddr_string(SPA(ap))); if (memcmp((char *)ESRC(eh), (char *)SHA(ap), 6) != 0) (void)printf(" (%s)", etheraddr_string(SHA(ap))); break; case ARPOP_REPLY: (void)printf("arp reply %s", ipaddr_string(SPA(ap))); if (memcmp((char *)ESRC(eh), (char *)SHA(ap), 6) != 0) (void)printf(" (%s)", etheraddr_string(SHA(ap))); (void)printf(" is-at %s", etheraddr_string(SHA(ap))); if (memcmp((char *)EDST(eh), (char *)THA(ap), 6) != 0) (void)printf(" (%s)", etheraddr_string(THA(ap))); break; case REVARP_REQUEST: (void)printf("rarp who-is %s tell %s", etheraddr_string(THA(ap)), etheraddr_string(SHA(ap))); break; case REVARP_REPLY: (void)printf("rarp reply %s at %s", etheraddr_string(THA(ap)), ipaddr_string(TPA(ap))); break; default: (void)printf("arp-#%d", op); default_print((u_char *)ap, caplen); return; } if (hrd != ARPHRD_ETHER) printf(" hardware #%d", hrd); }
SuffixTree_T SuffixTree_create(char* str, size_t length) { SuffixTree_T tree; SuffixTreeIndex_T phase , extension; char repeated_extension = 0; struct SuffixTreePos pos; if(str == NULL) return NULL; /* Allocating the tree */ tree = malloc(sizeof(struct SuffixTree_T)); check_mem(tree); tree->root = NULL; /* Calculating string length (with an ending terminator) */ tree->length = length+1; /* Allocating the only real string of the tree */ tree->tree_string = malloc((tree->length+1)*sizeof(char)); check_mem(tree->tree_string); memcpy(tree->tree_string+sizeof(char),str,length*sizeof(char)); tree->tree_string[tree->length] = '$'; /* Allocating the tree root node */ tree->root = create_node(0, 0, 0, 0); check(tree->root, "Creation of tree root failed."); tree->root->suffix_link = NULL; tree->e = 0; /* Initializing algorithm parameters */ extension = 2; phase = 2; /* Allocating first node, son of the root (phase 0), the longest path node */ tree->root->left_son = create_node(tree->root, 1, tree->length, 1); check(tree->root->left_son, "Node creation failed."); suffixless = NULL; pos.node = tree->root; pos.edge_pos = 0; /* Ukkonen's algorithm begins here */ int success = 0; for(; phase < tree->length; phase++) { /* Perform Single Phase Algorithm */ success = SPA(tree, &pos, phase, &extension, &repeated_extension); } check(success == 0, "Ukkonen's suffix tree construction algorithm failed."); SuffixTreeIndex_T counter = 0; label_nodes(tree->root, tree, &counter, 0); tree->num_nodes = counter; return tree; error: SuffixTree_delete(&tree); return NULL; }
#include "j.h" static F2(jtcanta); static A jtcants(J jt,A a,A w,A z){A a1,q,y;B*b,*c;I*u,wr,zr;P*wp,*zp; RZ(a&&w&&z); RZ(a=grade1(a)); wr=AR(w); wp=PAV(w); a1=SPA(wp,a); zr=AR(z); zp=PAV(z); ASSERT(wr==zr,EVNONCE); RZ(b=bfi(wr,a1,1)); GA(q,B01,wr,1,0); c=BAV(q); u=AV(a); DO(wr, c[i]=b[u[i]];); SPB(zp,a,ifb(wr,c)); SPB(zp,e,ca(SPA(wp,e))); RZ(y=fromr(grade1(indexof(a,a1)),SPA(wp,i))); RZ(q=grade1(y)); SPB(zp,i,from(q,y)); SPB(zp,x,from(q,canta(over(zero,increm(grade1(less(a,a1)))),SPA(wp,x)))); R z; } /* w is sparse */ #define CANTA(T,exp) \ {T*u=(T*)zv,*v=(T*)wv; \ DO(zn, exp; j=r-1; ++tv[j]; d+=mv[j]; \ while(j&&sv[j]==tv[j]){d+=mv[j-1]-mv[j]*sv[j]; tv[j]=0; ++tv[--j];}); \ } static F2(jtcanta){A m,s,t,z;B b;C*wv,*zv;I*av,c,d,j,k,*mv,r,*sv,*tv,wf,wr,*ws,zn,zr; RZ(a&&w); av=AV(a); ws=AS(w); wr=AR(w); r=jt->rank?jt->rank[1]:wr; jt->rank=0;
template <class T> complex<T> A_GGqqy_mpmpp_eval(const eval_param<T>& ep, const mass_param_coll& masses){ return( (complex<T>(0,-1)*pow(SPA(3,1),2))/ (SPA(3,5)*SPA(4,5)*SPA(1,2)) ); }