bfmacros.h

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

    for(int _n = (ns); _n < (ns)+(nc); ++_n) {                                                                     
        int nR = _n; nR += 0;                                                                                      
        for(int _j = 0; _j < _b_len[1]; ++_j) {                                                                    
            const int jR = _j + _b_lo[1];                                                                          
            const T *_th_pp = _th_p                                                                                
                + ((_b_lo[0] - _th_plo[0])                                                                         
                   + _th_plen[0]*(                                                                                 
                       (jR - _th_plo[1])                                                                           
                       + _n * _th_plen[1]));                                                                       
            const T &thisR = * _th_pp;                                                                             
            const int thisLen = _b_len[0];                                                                                  
                                                                                                                            
#define ForAllThisPencil(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) {                                                                      
        const int nR = _n;                                                                                          
        for(int _j = 0; _j < _b_len[1]; ++_j) {                                                                     
            const int jR = _j + _b_lo[1];                                                                           
            T *_th_pp = _th_p                                                                                       
                + ((_b_lo[0] - _th_plo[0])                                                                          
                   + _th_plen[0]*(                                                                                  
                       (jR - _th_plo[1])                                                                            
                       + _n * _th_plen[1]));                                                                        
            T &thisR = * _th_pp;                                                                                    
            const int thisLen = _b_len[0];                                                                          
                                                                                                                    
#define ForAllXBPencil(T,x,b,ns,nc)                                                                                 
{                                                                                                                   
    assert((x).contains(b));                                                                                        
    assert((ns) >= 0 && (ns) + (nc) <= (x).nComp());                                                                
    const int *_th_plo = (x).loVect();                                                                              
    const int *_th_plen =(x).size();                                                                                
    const int *_b_lo = (b).loVect();                                                                                       
    const int *_b_len = (b).size().getVect();                                                                      
    T* _th_p = (x) .dataPtr();                                                                                     
    for(int nR = (ns); nR < (ns)+(nc); ++nR) {                                                                     
        for(int _j = 0; _j < _b_len[1]; ++_j) {                                                                    
            const int jR = _j + _b_lo[1];                                                                          
            T *xR = _th_p                                                                                          
                + ((_b_lo[0] - _th_plo[0])                                                                         
                   + _th_plen[0]*(                                                                                 
                       (jR - _th_plo[1])                                                                           
                       + nR * _th_plen[1]));                                                                       
            const int thisLen = _b_len[0];                                                                         
                                                                                                                   
#define ForAllXBNN(T,x,b,ns,nc)                                                                                    
{                                                                                                                  
    assert((x).contains(b));                                                                                       
    assert((ns) >= 0 && (ns) + (nc) <= (x).nComp());                                                               
    const int *_x_plo = (x).loVect();                                                                              
    const int *_x_plen = (x).size();                                                                               
    const int *_b_lo = (b).loVect();                                                                               
    const int *_b_len = (b).size().getVect();                                                                      
    T* _x_p = (x) .dataPtr();                                                                                      
    for(int _n = (ns); _n < (ns)+(nc); ++_n) {                                                                     
        const int nR = _n;                                                                                         
        for(int _j = 0; _j < _b_len[1]; ++_j) {                                                                    
            const int jR = _j + _b_lo[1];                                                                          
            T *_x_pp = _x_p                                                                                        
                + ((_b_lo[0] - _x_plo[0])                                                                            
                       + _x_plen[0]*(                                                                                
                           (jR - _x_plo[1])                                                                          
                           + _n * _x_plen[1]));                                                                      
            for(int _i = 0; _i < _b_len[0]; ++_i, ++_x_pp) {                                                         
                const int iR = _i + _b_lo[0];                                                                        
                T &x##R = * _x_pp;                                                                                   
                                                                                                                     
#define ForAllXCBNN(T,x,b,ns,nc)                                                                                     
{                                                                                                                    
    assert(x.contains(b));                                                                                           
    assert((ns) >= 0 && (ns) + (nc) <= (x).nComp());                                                                 
    const int *_x_plo = (x).loVect();                                                                                
    const int *_x_plen = (x).size();                                                                                 
    const int *_b_lo = (b).loVect();                                                                                 
    const int *_b_len = (b).size().getVect();                                                                        
    const T* _x_p = (x).dataPtr();                                                                                   
    for(int _n = (ns); _n < (ns)+(nc); ++_n) {                                                                       
        const int nR = _n;                                                                                           
        for(int _j = 0; _j < _b_len[1]; ++_j) {                                                                      
            const int jR = _j + _b_lo[1];                                                                            
            const T *_x_pp = _x_p                                                                                    
                + ((_b_lo[0] - _x_plo[0])                                                                            
                       + _x_plen[0]*(                                                                                
                           (jR  - _x_plo[1])                                                                         
                           + _n * _x_plen[1]));                                                                      
            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;                                                                                      
        for(int _j = 0; _j < _b_len[1]; ++_j) {                                                                    
            const int jR = _j + _b_lo[1];