自学教程：C++ BF函数代码示例

node *insertNode(node *root, int cont){    if(root==NULL){        return createNode(cont);    }    else    if(cont>root->data) {        root->right=insertNode(root->right,cont);        if(BF(root)==-2){            if(cont>root->right->data)                root=RR(root);                else                    root=RL(root);        }    }    else    if(cont<root->data) {        root->left=insertNode(root->left,cont);        if(BF(root)==2){            if(cont < root->left->data)                root=LL(root);                else                  root=LR(root);        }    }    /*else{        if(cont==root->data) printf("the node %d already exists in the tree",cont);        return root;    }*/    root->ht=height(root);    return(root);}

void DOFInterpolation<EvalT, Traits>::evaluateFields(typename Traits::EvalData workset){  //Intrepid version:  // for (int i=0; i < val_qp.size() ; i++) val_qp[i] = 0.0;  // Intrepid::FunctionSpaceTools:: evaluate<ScalarT>(val_qp, val_node, BF);  for (int cell=0; cell < workset.numCells; ++cell) {    for (int qp=0; qp < numQPs; ++qp) {      if (2==numRank) {        typename PHAL::Ref<ScalarT>::type vqp = val_qp(cell,qp) = 0;        for (int node=0; node < numNodes; ++node) {          vqp += val_node(cell, node) * BF(cell, node, qp);        }      } else {        for (int level=0; level < numLevels; ++level) {          typename PHAL::Ref<ScalarT>::type vqp = val_qp(cell,qp,level);          vqp = 0;          for (int node=0; node < numNodes; ++node) {            vqp += val_node(cell, node, level) * BF(cell, node, qp);          }        }      }     }  }}

/*  Insert sessid and socket pair in AVL Tree		*/AVLTree_Node* insertion(AVLTree_Node *T,uint16_t x, struct node *head){    if(T==NULL)    {        T=(AVLTree_Node*)malloc(sizeof(AVLTree_Node));        T->data=x;	T->head = head;        T->left=NULL;        T->right=NULL;	     }    else        if(x > T->data)                // insert in right subtree        {            T->right=insertion(T->right,x,head);            if(BF(T)==-2)                if(x>T->right->data)                    T=RR(T);                else                    T=RL(T);        }        else            if(x<T->data)            {                T->left=insertion(T->left,x,head);                if(BF(T)==2)                    if(x < T->left->data)                        T=LL(T);                    else                        T=LR(T);            }            T->ht=height(T);	    //root=T;            return(T);}

/* Send the BC command to the device */static void stmp3xxx_mmc_bc(struct stmp3xxx_mmc_host *host){	struct mmc_command *cmd = host->cmd;	struct stmp3xxx_dma_descriptor *dma_desc = &host->dma_desc;	dma_desc->command->cmd = BM_APBH_CHn_CMD_WAIT4ENDCMD | BM_APBH_CHn_CMD_SEMAPHORE | BM_APBH_CHn_CMD_IRQONCMPLT | BF(0, APBH_CHn_CMD_XFER_COUNT) | BF(3, APBH_CHn_CMD_CMDWORDS) | BF(0, APBH_CHn_CMD_COMMAND);	/* NO_DMA_XFER */	dma_desc->command->pio_words[0] = BM_SSP_CTRL0_ENABLE |	    BM_SSP_CTRL0_IGNORE_CRC;	dma_desc->command->pio_words[1] = BF(cmd->opcode, SSP_CMD0_CMD) |	    BM_SSP_CMD0_APPEND_8CYC;	dma_desc->command->pio_words[2] = BF(cmd->arg, SSP_CMD1_CMD_ARG);	init_completion(&host->dma_done);	stmp3xxx_dma_reset_channel(host->dmach);	stmp3xxx_dma_go(host->dmach, dma_desc, 1);	wait_for_completion(&host->dma_done);	cmd->error = stmp3xxx_mmc_cmd_error(host->status);	if (stmp3xxx_dma_running(host->dmach))		dev_dbg(host->dev, "DMA command not finished/n");	if (cmd->error) {		dev_dbg(host->dev, "Command error 0x%x/n", cmd->error);		stmp3xxx_dma_reset_channel(host->dmach);	}}

node * insert(node *T,int x){               if(T==NULL)               {                              T=(node*)malloc(sizeof(node));                              T->data=x;                              T->left=NULL;                              T->right=NULL;               }               else                              if(x > T->data)                // insert in right subtree                              {                                             T->right=insert(T->right,x);                                             if(BF(T)==-2)                                                            if(x>T->right->data)                                                                           T=RR(T);                                                            else                                                                           T=RL(T);                              }                              else                                             if(x<T->data)                                             {                                                            T->left=insert(T->left,x);                                                            if(BF(T)==2)                                                                           if(x < T->left->data)                                                                                          T=LL(T);                                                                           else                                                                                          T=LR(T);                                             }                                             T->ht=height(T);                                             return(T);}

void stmp37xx_circ_advance_active(struct stmp37xx_circ_dma_chain *chain,		unsigned count){	void __iomem *c;	u32 mask_clr, mask;	BUG_ON(chain->free_count < count);	chain->free_count -= count;	chain->free_index += count;	chain->free_index %= chain->total_count;	chain->active_count += count;	switch (chain->bus) {	case STMP3XXX_BUS_APBH:		c = REGS_APBH_BASE + HW_APBH_CHn_SEMA + 0x70 * chain->channel;		mask_clr = BM_APBH_CHn_SEMA_INCREMENT_SEMA;		mask = BF(count, APBH_CHn_SEMA_INCREMENT_SEMA);		break;	case STMP3XXX_BUS_APBX:		c = REGS_APBX_BASE + HW_APBX_CHn_SEMA + 0x70 * chain->channel;		mask_clr = BM_APBX_CHn_SEMA_INCREMENT_SEMA;		mask = BF(count, APBX_CHn_SEMA_INCREMENT_SEMA);		break;	default:		BUG();		return;	}	/* Set counting semaphore (kicks off transfer). Assumes	   peripheral has been set up correctly */	stmp3xxx_clearl(mask_clr, c);	stmp3xxx_setl(mask, c);}

static int set_otp_timing(void){	u32 clk_rate = 0;	u32 relax, strobe_read, strobe_prog;	u32 timing = 0;	/* get clock */	clk_rate = mxc_get_clock(MXC_IPG_CLK);	if (clk_rate == -1) {		printf("ERROR: mxc_get_clock failed/n");		return -1;	}	log("clk_rate: %d.", clk_rate);	relax = clk_rate / (1000000000 / DEF_RELAX) - 1;	strobe_prog = clk_rate / (1000000000 / 10000) + 2 * (DEF_RELAX + 1) - 1;	strobe_read = clk_rate / (1000000000 / 40) + 2 * (DEF_RELAX + 1) - 1;	timing = BF(relax, OCOTP_TIMING_RELAX);	timing |= BF(strobe_read, OCOTP_TIMING_STROBE_READ);	timing |= BF(strobe_prog, OCOTP_TIMING_STROBE_PROG);	log("timing: 0x%X", timing);	writel(timing, IMX_OTP_BASE + HW_OCOTP_TIMING);	return 0;}

int timing_ctrl_rams(int ss){	__raw_writel(BF(ss, DIGCTL_ARMCACHE_VALID_SS) |				      BF(ss, DIGCTL_ARMCACHE_DRTY_SS) |				      BF(ss, DIGCTL_ARMCACHE_CACHE_SS) |				      BF(ss, DIGCTL_ARMCACHE_DTAG_SS) |				      BF(ss, DIGCTL_ARMCACHE_ITAG_SS),				      DIGCTRL_BASE_ADDR + HW_DIGCTL_ARMCACHE);	return 0;}

/* * Change divisors to reflect the rate of 'hz'. Note that we should not * play with clock rate, because the same source is used to clock both * SSP ports. */static voidstmp3xxx_set_sclk_speed(struct stmp3xxx_mmc_host *host, unsigned int hz){	unsigned long ssp;	u32 div1, div2;	u32 val;	struct stmp3xxxmmc_platform_data *pdata = host->dev->platform_data;	if (get_evk_board_version() == 1) {		/*EVK Ver1 max clock is 12M */		if (hz > 12000000)			hz = 12000000;	}	if (pdata && pdata->setclock) {		/*		   if the SSP is buggy and platform provides callback...		   well, let it be.		 */		host->clkrt = pdata->setclock(hz);		return;	}	/*	   ...but the RightIdea(tm) is to set divisors to match	   the requested clock.	 */	hz /= 1000;	ssp = clk_get_rate(host->clk);	for (div1 = 2; div1 < 254; div1 += 2) {		div2 = ssp / hz / div1;		if (div2 < 0x100)			break;	}	if (div1 >= 254) {		dev_err(host->dev, "Cannot set clock to %dkHz/n", hz);		return;	}	dev_dbg(host->dev, "Setting clock rate to %ld kHz [%x+%x] "		"(requested %d), source %ldk/n",		ssp / div1 / div2, div1, div2, hz, ssp);	val = __raw_readl(host->ssp_base + HW_SSP_TIMING);	val &= ~(BM_SSP_TIMING_CLOCK_DIVIDE | BM_SSP_TIMING_CLOCK_RATE);	val |= BF(div1, SSP_TIMING_CLOCK_DIVIDE) |		      BF(div2 - 1, SSP_TIMING_CLOCK_RATE);	__raw_writel(val, host->ssp_base + HW_SSP_TIMING);	host->clkrt = ssp / div1 / div2 * 1000;}

node * Delete(node *T,int x){       node *p;               if(T==NULL)               {                              return NULL;               }               else                              if(x > T->data)                // insert in right subtree                              {                                             T->right=Delete(T->right,x);                                             if(BF(T)==2)                                                            if(BF(T->left)>=0)                                                                           T=LL(T);                                                            else                                                                           T=LR(T);                              }                              else                                             if(x<T->data)                                                            {                                                                           T->left=Delete(T->left,x);                                                                           if(BF(T)==-2)//Rebalance during windup                                                                                          if(BF(T->right)<=0)                                                                                                         T=RR(T);                                                                                          else                                                                                                         T=RL(T);                                                            }                                             else                                               {                                                 //data to be deleted is found                                             if(T->right !=NULL)                                                            {  //delete its inordersuccesor                                                                  p=T->right;                                                            while(p->left != NULL)                                                                             p=p->left;                                                                  T->data=p->data;                                                                  T->right=Delete(T->right,p->data);                                                            if(BF(T)==2)//Rebalance during windup                                                                                          if(BF(T->left)>=0)                                                                                                         T=LL(T);                                                                                          else                                                                                                         T=LR(T);                                                               }                                             else                                                            return(T->left);                                               }               T->ht=height(T);               return(T);}

static struct avl_node *_avl_delete(struct avl_node *n, int key){    if(!n) return NULL;    if(key < K(n)) L(n) = _avl_delete(L(n), key);    else if(key > K(n)) R(n) = _avl_delete(R(n), key);    else { // key == K(n)        if(NULL == L(n) || NULL == R(n)) {            struct avl_node *tmp = L(n) ? L(n) : R(n);            if(tmp) {                *n = *tmp; // copy contents of child to n            }            else { // n is leaf                tmp = n;                n = NULL;            }            free(tmp);        }        else { // two children case            struct avl_node *d = _avl_minimum(n);            K(n) = K(d);            R(n) = _avl_delete(d, key);        }    }    // no child case    if(!n) return NULL;    H(n) = MAX(HH(n->left), HH(n->right)) + 1;    int bf = BF(n);    if(bf > 1) {        if(0 > BF(L(n))) { // LR case            L(n) = _leftRotate(L(n));        }        // else LL case        return _rightRotate(n);    }    if(bf < -1) {        if(0 < BF(R(n))) { // RL case            R(n) = _rightRotate(R(n));        }        // else RR case        return _leftRotate(n);    }            return n;}

void CismSurfaceGradFO<EvalT, Traits>::evaluateFields(typename Traits::EvalData workset){  for (std::size_t cell=0; cell < workset.numCells; ++cell) {    for (std::size_t qp=0; qp < numQPs; ++qp) {      gradS_qp(cell,qp,0) = dsdx_node(cell, 0) * BF(cell, 0, qp);       gradS_qp(cell,qp,1) = dsdy_node(cell, 0) * BF(cell, 0, qp);       for (std::size_t node=1; node < numNodes; ++node) {        gradS_qp(cell,qp,0) += dsdx_node(cell, node) * BF(cell, node, qp);         gradS_qp(cell,qp,1) += dsdy_node(cell, node) * BF(cell, node, qp);       }    }}}

bool testKNNG(unsigned int Size, unsigned int k, T min, T max, int num_threads){  typedef reviver::dpoint<T, DIM> Point;  std::vector<Point> data;  std::vector<long unsigned int> bf_ans;  data.resize(Size);    for(unsigned int i=0;i < data.size();++i)    {      data[i]  = newRandomPoint<Point, T>(min, max);    }  bruteNN<Point> BF(&data[0], data.size());  sfcnn_knng<Point, DIM, T> SFC(&data[0], data.size(), k, num_threads);  for(unsigned int i=0;i < data.size();++i)    {      BF.ksearch(data[i], k+1, bf_ans);      for(unsigned int j=1;j < k+1;++j)	{	  if(bf_ans[j] != SFC[i][j-1])	    return false;	}    }  return true;}

static int fuse_read_addr(struct ocotp_priv *priv, u32 addr, u32 *pdata){	u32 ctrl_reg;	int ret;	writel(OCOTP_CTRL_ERROR, priv->base + OCOTP_CTRL_CLR);	ctrl_reg = readl(priv->base + OCOTP_CTRL);	ctrl_reg &= ~OCOTP_CTRL_ADDR_MASK;	ctrl_reg &= ~OCOTP_CTRL_WR_UNLOCK_MASK;	ctrl_reg |= BF(addr, OCOTP_CTRL_ADDR);	writel(ctrl_reg, priv->base + OCOTP_CTRL);	writel(OCOTP_READ_CTRL_READ_FUSE, priv->base + OCOTP_READ_CTRL);	ret = imx6_ocotp_wait_busy(priv, 0);	if (ret)		return ret;	if (readl(priv->base + OCOTP_CTRL) & OCOTP_CTRL_ERROR)		*pdata = 0xbadabada;	else		*pdata = readl(priv->base + OCOTP_READ_FUSE_DATA);	return 0;}

BoolNV30EXACheckComposite(int op, PicturePtr psPict,		PicturePtr pmPict,		PicturePtr pdPict){	nv_pict_surface_format_t *fmt;	nv_pict_op_t *opr;	opr = NV30_GetPictOpRec(op);	if (!opr)		NOUVEAU_FALLBACK("unsupported blend op 0x%x/n", op);	fmt = NV30_GetPictSurfaceFormat(pdPict->format);	if (!fmt)		NOUVEAU_FALLBACK("dst picture format 0x%08x not supported/n",				pdPict->format);	if (!NV30EXACheckCompositeTexture(psPict, pdPict, op))		NOUVEAU_FALLBACK("src picture/n");	if (pmPict) {		if (pmPict->componentAlpha &&				PICT_FORMAT_RGB(pmPict->format) &&				opr->src_alpha && opr->src_card_op != BF(ZERO))			NOUVEAU_FALLBACK("mask CA + SA/n");		if (!NV30EXACheckCompositeTexture(pmPict, pdPict, op))			NOUVEAU_FALLBACK("mask picture/n");	}	return TRUE;}

//BEGIN send::host_listmessage_udp::send::host_list::host_list(const net::buffer & random,	const std::string & local_ID,	const std::list<net::endpoint> & hosts){	assert(random.size() == 4);	assert(hosts.size() <= protocol_udp::host_list_elements);	bit_field BF(16);	unsigned cnt = 0;	for(std::list<net::endpoint>::const_iterator it_cur = hosts.begin(),		it_end = hosts.end(); it_cur != it_end; ++it_cur)	{		if(it_cur->version() == net::IPv4){			BF[cnt] = 0;		}else{			BF[cnt] = 1;		}		++cnt;	}	buf.append(protocol_udp::host_list)		.append(random)		.append(convert::hex_to_bin(local_ID))		.append(BF.get_buf());	//append addresses	for(std::list<net::endpoint>::const_iterator it_cur = hosts.begin(),		it_end = hosts.end(); it_cur != it_end; ++it_cur)	{		buf.append(it_cur->IP_bin())			.append(it_cur->port_bin());	}}

static struct avl_node *_avlInsert(struct avl_node *n, int key){    if(!n) return _avlNewNode(key);    if(key < K(n)) {        L(n) = _avlInsert(L(n), key);    }    else {        R(n) = _avlInsert(R(n), key);    }    H(n) = MAX(HH(n->left), HH(n->right)) + 1;    int bf = BF(n);    if(bf > 1) {        if(key > K(L(n))) { // LR case            L(n) = _leftRotate(L(n));        }        // else LL case        return _rightRotate(n);    }    if(bf < -1) {        if(key < K(R(n))) { // RL case            R(n) = _rightRotate(R(n));        }        // else RR case        return _leftRotate(n);    }    return n;}

bool testNN(unsigned int Size, unsigned int k, T min, T max){  typedef reviver::dpoint<T, DIM> Point;  std::vector<Point> data;  std::vector<Point> query;  std::vector<long unsigned int> sfcnn_ans;  std::vector<long unsigned int> bf_ans;  data.resize(Size);  query.resize(Size);    for(unsigned int i=0;i < data.size();++i)    {      data[i]  = newRandomPoint<Point, T>(min, max);      query[i] = newRandomPoint<Point, T>(min, max);    }  bruteNN<Point> BF(&data[0], data.size());  sfcnn<Point, DIM, T> SFC(&data[0], data.size());  for(unsigned int i=0;i < data.size();++i)    {      BF.ksearch(query[i], k, bf_ans);      SFC.ksearch(query[i], k, sfcnn_ans);             for(unsigned int j=0;j < Point::__DIM;++j)	{	  if(bf_ans[j] != sfcnn_ans[j])	    return false;	}    }  return true;}

bool message_udp::recv::host_list::recv(const net::buffer & recv_buf,	const net::endpoint & endpoint){	if(!expect(recv_buf)){		return false;	}	std::string remote_ID(convert::bin_to_hex(std::string(		reinterpret_cast<const char *>(recv_buf.data())+5, 20)));	bit_field BF(recv_buf.data()+25, 2, 16);	std::list<net::endpoint> hosts;	unsigned offset = protocol_udp::host_list_size;	for(unsigned x=0; x<16 && offset != recv_buf.size(); ++x){		if(BF[x] == 0){			//IPv4			boost::optional<net::endpoint> ep = net::bin_to_endpoint(				recv_buf.str(offset, 4), recv_buf.str(offset + 4, 2));			if(ep){				hosts.push_back(*ep);			}			offset += 6;		}else{			//IPv6			boost::optional<net::endpoint> ep = net::bin_to_endpoint(				recv_buf.str(offset, 16), recv_buf.str(offset + 16, 2));			if(ep){				hosts.push_back(*ep);			}			offset += 18;		}	}	func(endpoint, remote_ID, hosts);	return true;}

void DOFInterpolation<EvalT, Traits>::evaluateFields(typename Traits::EvalData workset){  //Intrepid version:  // for (int i=0; i < val_qp.size() ; i++) val_qp[i] = 0.0;  // Intrepid::FunctionSpaceTools:: evaluate<ScalarT>(val_qp, val_node, BF);  for (std::size_t cell=0; cell < workset.numCells; ++cell) {    for (std::size_t qp=0; qp < numQPs; ++qp) {      ScalarT& vqp = val_qp(cell,qp);      vqp = val_node(cell, 0) * BF(cell, 0, qp);      for (std::size_t node=1; node < numNodes; ++node) {        vqp += val_node(cell, node) * BF(cell, node, qp);      }    }  }}

void inorder4(node *T){    if(T!=NULL)    {        inorder4(T->left);        printf(" %d(Bf=%d)",T->data,BF(T));        inorder4(T->right);    }}

void preorder(node *T){               if(T!=NULL)               {                              printf("%d(Bf=%d) ",T->data,BF(T));                              preorder(T->left);                              preorder(T->right);               }}

void FFT::fft8(Complex *z) {	float t1, t2, t3, t4, t5, t6, t7, t8;	fft4(z);	BF(t1, z[5].re, z[4].re, -z[5].re);	BF(t2, z[5].im, z[4].im, -z[5].im);	BF(t3, z[7].re, z[6].re, -z[7].re);	BF(t4, z[7].im, z[6].im, -z[7].im);	BF(t8, t1, t3, t1);	BF(t7, t2, t2, t4);	BF(z[4].re, z[0].re, z[0].re, t1);	BF(z[4].im, z[0].im, z[0].im, t2);	BF(z[6].re, z[2].re, z[2].re, t7);	BF(z[6].im, z[2].im, z[2].im, t8);	TRANSFORM(z[1], z[3], z[5], z[7], sqrthalf, sqrthalf);}

void DOFTensorInterpolationBase<EvalT, Traits, ScalarT>::evaluateFields(typename Traits::EvalData workset){  for (std::size_t cell=0; cell < workset.numCells; ++cell) {    for (std::size_t qp=0; qp < numQPs; ++qp) {      for (std::size_t i=0; i<vecDim; i++) {        for (std::size_t j=0; j<vecDim; j++) {          // Zero out for node==0; then += for node = 1 to numNodes          typename PHAL::Ref<ScalarT>::type vqp = val_qp(cell,qp,i,j);          vqp = val_node(cell, 0, i, j) * BF(cell, 0, qp);          for (std::size_t node=1; node < numNodes; ++node) {            vqp += val_node(cell, node, i, j) * BF(cell, node, qp);          }        }      }    }  }}

void FFT::fft4(Complex *z) {	float t1, t2, t3, t4, t5, t6, t7, t8;	BF(t3, t1, z[0].re, z[1].re);	BF(t8, t6, z[3].re, z[2].re);	BF(z[2].re, z[0].re, t1, t6);	BF(t4, t2, z[0].im, z[1].im);	BF(t7, t5, z[2].im, z[3].im);	BF(z[3].im, z[1].im, t4, t8);	BF(z[3].re, z[1].re, t3, t7);	BF(z[2].im, z[0].im, t2, t5);}

static int otp_write_bits(int addr, u32 data, u32 magic){	u32 c; /* for control register */	/* init the control register */	c = __raw_readl(otp_base + HW_OCOTP_CTRL);	c &= ~BM_OCOTP_CTRL_ADDR;	c |= BF(addr, OCOTP_CTRL_ADDR);	c |= BF(magic, OCOTP_CTRL_WR_UNLOCK);	__raw_writel(c, otp_base + HW_OCOTP_CTRL);	/* init the data register */	__raw_writel(data, otp_base + HW_OCOTP_DATA);	otp_wait_busy(0);	mdelay(2); /* Write Postamble */	return 0;}

static void set_otp_timing(void){	unsigned long clk_rate = 0;	unsigned long strobe_read, relex, strobe_prog;	u32 timing = 0;	clk_rate = clk_get_rate(otp_clk);	/* do optimization for too many zeros */	relex = clk_rate / (1000000000 / DEF_RELAX) - 1;	strobe_prog = clk_rate / (1000000000 / 10000) + 2 * (DEF_RELAX + 1) - 1;	strobe_read = clk_rate / (1000000000 / 40) + 2 * (DEF_RELAX + 1) - 1;	timing = BF(relex, OCOTP_TIMING_RELAX);	timing |= BF(strobe_read, OCOTP_TIMING_STROBE_READ);	timing |= BF(strobe_prog, OCOTP_TIMING_STROBE_PROG);	__raw_writel(timing, otp_base + HW_OCOTP_TIMING);}

static inline void fft8(FFTComplex *z){    fft4(z);    FFTSample t1,t2,t3,t4,t7,t8;        BF(t1, z[5].re, z[4].re, -z[5].re);    BF(t2, z[5].im, z[4].im, -z[5].im);    BF(t3, z[7].re, z[6].re, -z[7].re);    BF(t4, z[7].im, z[6].im, -z[7].im);    BF(t8, t1, t3, t1);    BF(t7, t2, t2, t4);    BF(z[4].re, z[0].re, z[0].re, t1);    BF(z[4].im, z[0].im, z[0].im, t2);    BF(z[6].re, z[2].re, z[2].re, t7);    BF(z[6].im, z[2].im, z[2].im, t8);    z++;    TRANSFORM_EQUAL(z,2);}

void inorder(node *T){               if(T!=NULL)               {                              inorder(T->left);                              printf("%d ",T->data,BF(T));                              inorder(T->right);               }}

static void fft4(FFTComplex *z){    FFTSample t1, t2, t3, t4, t5, t6, t7, t8;    BF(t3, t1, z[0].re, z[1].re);    BF(t8, t6, z[3].re, z[2].re);    BF(z[2].re, z[0].re, t1, t6);    BF(t4, t2, z[0].im, z[1].im);    BF(t7, t5, z[2].im, z[3].im);    BF(z[3].im, z[1].im, t4, t8);    BF(z[3].re, z[1].re, t3, t7);    BF(z[2].im, z[0].im, t2, t5);}