bfmacros.h

自适应网格划分通用程序包

        const int nR = _n;                                                                                              
        const T *_x_pp = _x_p                                                                                           
            + ((_b_lo[0] - _x_plo[0])                                                                                   
               + _n * _x_plen[0]);                                                                                      
        for(int _i = 0; _i < _b_len[0]; ++_i) {                                                                         
            const int iR = _i + _b_lo[0];                                                                               
            const T & x##R = _x_pp[_i];                                                                                     
                                                                                                                            
#define ForAllThisBNN(T,b,ns,nc)                                                                                      
{                                                                                                                     
    assert(contains(b));                                                                                              
    assert((ns) >= 0 && (ns) + (nc) <= nComp());                                                                      
    const int *_th_plo = loVect();                                                                                    
    const int *_th_plen = size();                                                                                     
    const int *_b_lo = (b).loVect();                                                                                  
    const int *_b_len = (b).size().getVect();                                                                         
    T* _th_p = dptr;                                                                                                  
    for(int _n = (ns); _n < (ns)+(nc); ++_n) {                                                                        
        int nR = _n; nR += 0;                                                                                         
        T *_th_pp = _th_p                                                                                             
            + ((_b_lo[0] - _th_plo[0])                                                                                
               + _n * _th_plen[0]);                                                                                   
        for(int _i = 0; _i < _b_len[0]; ++_i, ++_th_pp) {                                                             
            int iR = _i + _b_lo[0]; iR += 0;                                                                          
            T &thisR = * _th_pp;                                                                                            
                                                                                                                            
#define ForAllThisCBNN(T,b,ns,nc)                                                                                    
{                                                                                                                    
    assert(contains(b));                                                                                             
    assert((ns) >= 0 && (ns) + (nc) <= nComp());                                                                     
    const int *_th_plo = loVect();                                                                                   
    const int *_th_plen = size();                                                                                    
    const int *_b_lo = (b).loVect();                                                                                 
    const int *_b_len = (b).size().getVect();                                                                        
    const T* _th_p = dptr;                                                                                           
    for(int _n = (ns); _n < (ns)+(nc); ++_n) {                                                                       
        const int nR = _n;                                                                                           
        const T *_th_pp = _th_p                                                                                      
            + ((_b_lo[0] - _th_plo[0])                                                                               
               + _n * _th_plen[0]);                                                                                  
        for(int _i = 0; _i < _b_len[0]; ++_i) {                                                                      
            const int iR = _i + _b_lo[0];                                                                            
            const T &thisR = _th_pp[_i];                                                                                    
                                                                                                                            
#define ForAllThisBNNXC(T,b,ns,nc,x,nss)                                                                                 
{                                                                                                                        
    assert((ns) >= 0 && (ns) + (nc) <= nComp());                                                                         
    assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                                                                   
    Box _subbox_((x).box());                                                                                             
    _subbox_ &= box();                                                                                                   
    _subbox_ &= b;                                                                                                       
    if(!_subbox_.isEmpty()) {                                                                                            
        const int *_th_plo = loVect();                                                                                   
        const int *_th_plen = size();                                                                                    
        const int *_x_plo = (x).loVect();                                                                                
        const int *_x_plen = (x).size();                                                                                 
        const int *_subbox_lo = _subbox_.loVect();                                                                       
        const int *_subbox_len = _subbox_.size().getVect();                                                              
        T* _th_p = dataPtr(ns);                                                                                          
        const T* _x_p  = (x).dataPtr(nss);                                                                               
        for(int _n = 0; _n < (nc); ++_n) {                                                                               
            int nR = _n; nR += 0;                                                                                        
            T *_th_pp = _th_p                                                                                            
                + ((_subbox_lo[0] - _th_plo[0])                                                                          
                   + _n * _th_plen[0]);                                                                                  
            const T *_x_pp = _x_p                                                                                        
                + ((_subbox_lo[0] - _x_plo[0])                                                                           
                   + _n * _x_plen[0]);                                                                                   
            for(int _i = 0; _i < _subbox_len[0]; ++_i, ++_th_pp) {                                                       
                int iR = _i + _subbox_lo[0]; iR += 0;                                                                    
                T &thisR = * _th_pp; const T & x##R = _x_pp[_i];                                                            
                                                                                                                            
#define ForAllThisCBNNXC(T,b,ns,nc,x,nss)                                                                                
{                                                                                                                        
    assert((ns) >= 0 && (ns) + (nc) <= nComp());                                                                         
    assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                                                                   
    Box _subbox_((x).box());                                                                                             
    _subbox_ &= box();                                                                                                   
    _subbox_ &= b;                                                                                                       
    if(!_subbox_.isEmpty()) {                                                                                            
        const int *_th_plo = loVect();                                                                                   
        const int *_th_plen = size();                                                                                    
        const int *_x_plo = (x).loVect();                                                                                
        const int *_x_plen = (x).size();                                                                                 
        const int *_subbox_lo = _subbox_.loVect();                                                                       
        const int *_subbox_len = _subbox_.size().getVect();                                                              
        const T* _th_p = dataPtr(ns);                                                                               
        const T* _x_p  = (x).dataPtr(nss);                                                                          
        for(int _n = 0; _n < (nc); ++_n) {                                                                          
            int nR = _n; nR += 0;                                                                                   
            const T *_th_pp = _th_p                                                                                 
                + ((_subbox_lo[0] - _th_plo[0])                                                                          
                   + _n * _th_plen[0]);                                                                                  
            const T *_x_pp = _x_p                                                                                        
                + ((_subbox_lo[0] - _x_plo[0])                                                                           
                   + _n * _x_plen[0]);                                                                                   
            for(int _i = 0; _i < _subbox_len[0]; ++_i, ++_th_pp) {                                                       
                int iR = _i + _subbox_lo[0]; iR += 0;                                                                    
                const T &thisR = * _th_pp; const T & x##R = _x_pp[_i];                                                      
                                                                                                                            
#define ForAllThisBNNXCBN(T,b,ns,nc,x,bx,nss)                                                                      
{                                                                                                                  
    assert((ns) >= 0 && (ns) + (nc) <= nComp());                                                                   
    assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                                                             
    assert(bx.sameSize((b)));                                                                                      
    if(!((b).isEmpty())) {                                                                                         
        const int *_th_plo = loVect();                                                                             
        const int *_th_plen = size();                                                                              
        const int *_x_plo = (x).loVect();                                                                          
        const int *_x_plen = (x).size();