获取证书的CN
@param aCert
@return
767542
private static String getIdentitiesFromCertficate(X509Certificate aCert) {
		String tDN = aCert.getSubjectDN().toString(); 
		String tPart = "";
		if ((tDN != null)) {
			String tSplitStr[] = tDN.substring(tDN.indexOf("CN=")).split("@");
			if (tSplitStr != null && tSplitStr.length > 2
					&& tSplitStr[2] != null)
				tPart = tSplitStr[2];
		}
		return tPart;
	}
143564
def from_cn(cls, common_name):
        
        # search with cn
        result_cn = [(cert['id'], [cert['cn']] + cert['altnames'])
                     for cert in cls.list({'status': ['pending', 'valid'],
                                           'items_per_page': 500,
                                           'cn': common_name})]
        # search with altname
        result_alt = [(cert['id'], [cert['cn']] + cert['altnames'])
                      for cert in cls.list({'status': ['pending', 'valid'],
                                            'items_per_page': 500,
                                            'altname': common_name})]

        result = result_cn + result_alt
        ret = {}
        for id_, fqdns in result:
            for fqdn in fqdns:
                ret.setdefault(fqdn, []).append(id_)

        cert_id = ret.get(common_name)
        if not cert_id:
            return

        return cert_id
865943
private static List<AtomNode> atomSegment(String sSentence, int start, int end)
    {
        if (end < start)
        {
            throw new RuntimeException("start=" + start + " < end=" + end);
        }
        List<AtomNode> atomSegment = new ArrayList<AtomNode>();
        int pCur = 0, nCurType, nNextType;
        StringBuilder sb = new StringBuilder();
        char c;


        //==============================================================================================
        // by zhenyulu:
        //
        // TODO: 使用一系列正则表达式将句子中的完整成分（百分比、日期、电子邮件、URL等）预先提取出来
        //==============================================================================================

        char[] charArray = sSentence.substring(start, end).toCharArray();
        int[] charTypeArray = new int[charArray.length];

        // 生成对应单个汉字的字符类型数组
        for (int i = 0; i < charArray.length; ++i)
        {
            c = charArray[i];
            charTypeArray[i] = CharType.get(c);

            if (c == '.' && i < (charArray.length - 1) && CharType.get(charArray[i + 1]) == CharType.CT_NUM)
                charTypeArray[i] = CharType.CT_NUM;
            else if (c == '.' && i < (charArray.length - 1) && charArray[i + 1] >= '0' && charArray[i + 1] <= '9')
                charTypeArray[i] = CharType.CT_SINGLE;
            else if (charTypeArray[i] == CharType.CT_LETTER)
                charTypeArray[i] = CharType.CT_SINGLE;
        }

        // 根据字符类型数组中的内容完成原子切割
        while (pCur < charArray.length)
        {
            nCurType = charTypeArray[pCur];

            if (nCurType == CharType.CT_CHINESE || nCurType == CharType.CT_INDEX ||
                nCurType == CharType.CT_DELIMITER || nCurType == CharType.CT_OTHER)
            {
                String single = String.valueOf(charArray[pCur]);
                if (single.length() != 0)
                    atomSegment.add(new AtomNode(single, nCurType));
                pCur++;
            }
            //如果是字符、数字或者后面跟随了数字的小数点“.”则一直取下去。
            else if (pCur < charArray.length - 1 && ((nCurType == CharType.CT_SINGLE) || nCurType == CharType.CT_NUM))
            {
                sb.delete(0, sb.length());
                sb.append(charArray[pCur]);

                boolean reachEnd = true;
                while (pCur < charArray.length - 1)
                {
                    nNextType = charTypeArray[++pCur];

                    if (nNextType == nCurType)
                        sb.append(charArray[pCur]);
                    else
                    {
                        reachEnd = false;
                        break;
                    }
                }
                atomSegment.add(new AtomNode(sb.toString(), nCurType));
                if (reachEnd)
                    pCur++;
            }
            // 对于所有其它情况
            else
            {
                atomSegment.add(new AtomNode(charArray[pCur], nCurType));
                pCur++;
            }
        }

//        logger.trace("原子分词:" + atomSegment);
        return atomSegment;
    }
581745
public void getEachCellContent(int YNum, int cc, TableCandidate tc) {
    	int footnoteLineIndex = tc.getFootnoteBeginRow();
    	String[] contentsInRows = new String[footnoteLineIndex];
    	float[] leftX_tableColumns = tc.getLeftX_tableColumns();
    	float[] rightX_tableColumns = tc.getRightX_tableColumns();
    	String[][] cells = new String[YNum][cc];
		boolean[][] crossCells = new boolean[YNum][cc];
		for (int tt=0; tt<tc.getRows().size(); tt++) {
			for (int qq=0; qq<cc; qq++) {
				cells[tt][qq] = "";
				crossCells[tt][qq]=false; 
			}
		}
    	for (int tt=0; tt<footnoteLineIndex; tt++) {
			String cellsThisLine = "";
			TableRow row = tc.getRows().get(tt);
			int cellThisLine = row.getCells().size(); //  pmoj.objectNum_eachY[tt];
			for (int zz=0; zz<cellThisLine; zz++) {
				for (int qq=0; qq<cc; qq++) {
					if ( (row.getCells().get(zz).getX()>=leftX_tableColumns[qq]) 
					&& (row.getCells().get(zz).getEndX()<=rightX_tableColumns[qq]) ) 
							cells[tt][qq] =cells[tt][qq] + row.getCells().get(zz).getText() + " ";
					if ((row.getCells().get(zz).getX()<leftX_tableColumns[qq]) 
					&&(leftX_tableColumns[qq]<=row.getCells().get(zz).getEndX()) )
							cells[tt][qq] = cells[tt][qq] +  row.getCells().get(zz).getText() + " ";
					if ((leftX_tableColumns[qq]>=row.getCells().get(zz).getX()) 
					&& (row.getCells().get(zz).getX()>=rightX_tableColumns[qq]) 
					&&(rightX_tableColumns[qq]<row.getCells().get(zz).getEndX()) )
						cells[tt][qq] = cells[tt][qq] +  row.getCells().get(zz).getText() + " ";
				}
			}
			for (int zz=0; zz<cellThisLine; zz++) {
				int crossCellBegin = 1000;
				int crossCellEnd=0;
				for (int qq=0; qq<cc; qq++) {
					if ( (qq>0) && (cells[tt][qq-1].length()==0) 
					&& (row.getCells().get(zz).getX()<=rightX_tableColumns[qq-1]) 
					&& (row.getCells().get(zz).getX()<leftX_tableColumns[qq]) 
					&& (leftX_tableColumns[qq]<=row.getCells().get(zz).getEndX()) ) {
						crossCells[tt][qq]=true;
						crossCells[tt][qq-1]=true;
						cells[tt][qq-1] = row.getCells().get(zz).getText();
						crossCellBegin=qq-1;
					}
					if ((qq<(cc-1)) && (cells[tt][qq+1].length()==0) 
					&& (row.getCells().get(zz).getEndX()>=leftX_tableColumns[qq+1]) 
					&& (row.getCells().get(zz).getX()<=rightX_tableColumns[qq]) 
					&& (rightX_tableColumns[qq]<row.getCells().get(zz).getEndX()) ) {
						crossCells[tt][qq]=true;
						crossCells[tt][qq+1]=true;
						cells[tt][qq+1] = row.getCells().get(zz).getText();
						crossCellEnd=qq+1;
					}
				}
			}
			for (int qq=0; qq<cc; qq++) {
				cellsThisLine = cellsThisLine + cells[tt][qq] + "; ";
			}
			contentsInRows[tt]=cellsThisLine;
		}
    	tc.setCells(cells);
    	tc.setCrossCells(crossCells);
    }
1115289
public synchronized List<String> propertyListOf(Class<?> c) {
        String cn = c.getName();
        List<String> ls = repo.get(cn);
        if (ls != null) {
            return ls;
        }
        Set<Class<?>> circularReferenceDetector = new HashSet<>();
        ls = propertyListOf(c, circularReferenceDetector, null);
        repo.put(c.getName(), ls);
        return ls;
    }
1311642
static CharSequence chomp(CharSequence cs) {
        if (cs != null) {
            final int len = cs.length();
            if (len > 1 && cs.charAt(len - 2) == '\r' && cs.charAt(len - 1) == '\n') {
                return cs.subSequence(0, len - 2);
            } else if (len > 0 && cs.charAt(len - 1) == '\n') {
                return cs.subSequence(0, len - 1);
            }
        }
        return cs;
    }
1093466
public static int cusparseXcsrgemmNnz(
        cusparseHandle handle, 
        int transA, 
        int transB, 
        int m, 
        int n, 
        int k, 
        cusparseMatDescr descrA, 
        int nnzA, 
        Pointer csrSortedRowPtrA, 
        Pointer csrSortedColIndA, 
        cusparseMatDescr descrB, 
        int nnzB, 
        Pointer csrSortedRowPtrB, 
        Pointer csrSortedColIndB, 
        cusparseMatDescr descrC, 
        Pointer csrSortedRowPtrC, 
        Pointer nnzTotalDevHostPtr)
    {
        return checkResult(cusparseXcsrgemmNnzNative(handle, transA, transB, m, n, k, descrA, nnzA, csrSortedRowPtrA, csrSortedColIndA, descrB, nnzB, csrSortedRowPtrB, csrSortedColIndB, descrC, csrSortedRowPtrC, nnzTotalDevHostPtr));
    }
208466
public static DZcsd cs_scc(DZcs A)
	{
		int n, i, k, b, nb = 0, top, xi[], pstack[], p[], r[], Ap[], ATp[], rcopy[], Blk[] ;
		DZcs AT ;
		DZcsd D ;
		if (!CS_CSC (A)) return (null) ; 		/* check inputs */
		n = A.n ; Ap = A.p ;
		D = cs_dalloc (n, 0) ;				/* allocate result */
		AT = cs_transpose (A, false) ;			/* AT = A' */
		xi = new int [2*n+1] ;				/* get workspace */
		if (D == null || AT == null || xi == null)
			return (cs_ddone (D, AT, xi, false)) ;
		Blk = xi ; rcopy = xi ;
		int rcopy_offset = n ;
		pstack = xi ;
		int pstack_offset = n ;
		p = D.p ; r = D.r ; ATp = AT.p ;
		top = n ;
		for (i = 0 ; i < n ; i++)			/* first dfs(A) to find finish times (xi) */
		{
			if (!CS_MARKED (Ap, i))
			top = cs_dfs (i, A, top, xi, 0, pstack, pstack_offset, null, 0) ;
		}
		for (i = 0 ; i < n ; i++) CS_MARK (Ap, i) ;	/* restore A; unmark all nodes*/
		top = n ; nb = n ;
		for (k = 0 ; k < n ; k++)			/* dfs(A') to find strongly connnected comp */
		{
			i = xi [k] ;				/* get i in reverse order of finish times */
			if (CS_MARKED (ATp, i)) continue ;	/* skip node i if already ordered */
			r [nb--] = top ;			/* node i is the start of a component in p */
			top = cs_dfs (i, AT, top, p, 0, pstack, pstack_offset, null, 0) ;
		}
		r [nb] = 0 ;					/* first block starts at zero; shift r up */
		for (k = nb ; k <= n ; k++) r [k-nb] = r [k] ;
		D.nb = nb = n - nb ;				/* nb = # of strongly connected components */
		for (b = 0 ; b < nb ; b++)			/* sort each block in natural order */
		{
			for (k = r [b] ; k < r [b+1] ; k++) Blk [p [k]] = b ;
		}
		for (b = 0 ; b <= nb ; b++) rcopy [rcopy_offset + b] = r [b] ;
		for (i = 0 ; i < n ; i++) p [rcopy [rcopy_offset + Blk [i]]++] = i ;
		return (D) ;
	}
209777
public static <T extends Comparable<? super T>> int compare(T c1, T c2) {
		return CompareUtil.compare(c1, c2);
	}
801367
public double distance(final Coordinate c) {
        final double dx = getX() - c.getX();
        final double dy = getY() - c.getY();
        return Math.sqrt(dx * dx + dy * dy);
    }
1215673
public static int cnNumericToArabic( String cnn, boolean flag ) 
    {
        cnn = cnn.trim();
        if ( cnn.length() == 1 ) return isCNNumeric(cnn.charAt(0));
        
        if ( flag ) cnn = cnn.replace('佰', '百')
                .replace('仟', '千').replace('拾', '十').replace('零', ' ');
        
        int yi = -1, wan = -1, qian = -1, bai = -1, shi = -1;
        int val = 0;
        yi = cnn.lastIndexOf('亿');
        if ( yi > -1 ) {
            val += cnNumericToArabic( cnn.substring(0, yi), false ) * 100000000;
            if ( yi < cnn.length() - 1 ) {
                cnn = cnn.substring(yi + 1, cnn.length());
            } else {
                cnn = "";
            }
            
            if ( cnn.length() == 1 ) {
                int arbic = isCNNumeric(cnn.charAt(0));
                if ( arbic <= 10 )
                    val += arbic * 10000000;
                cnn = "";
            }
        }
        
        wan = cnn.lastIndexOf('万');
        if ( wan > -1 ) {
            val += cnNumericToArabic( cnn.substring(0, wan), false ) * 10000;
            if ( wan < cnn.length() - 1 ) {
                cnn = cnn.substring(wan + 1, cnn.length());
            } else {
                cnn = "";
            }
            
            if ( cnn.length() == 1 ) {
                int arbic = isCNNumeric(cnn.charAt(0));
                if ( arbic <= 10 )
                    val += arbic * 1000;
                cnn = "";
            }
        }
        
        qian = cnn.lastIndexOf('千'); 
        if ( qian > -1 ) {
            val +=  cnNumericToArabic( cnn.substring(0, qian), false ) * 1000;
            if ( qian < cnn.length() - 1 ) {
                 cnn = cnn.substring(qian + 1, cnn.length());
            } else {
                cnn = "";
            }
            
            if ( cnn.length() == 1 ) {
                int arbic = isCNNumeric(cnn.charAt(0));
                if ( arbic <= 10 )
                    val += arbic * 100;
                cnn = "";
            }
        }
        
        bai = cnn.lastIndexOf('百');
        if ( bai > -1 ) {
            val += cnNumericToArabic( cnn.substring(0, bai), false ) * 100;
            if ( bai < cnn.length() - 1 ) {
                cnn = cnn.substring(bai + 1, cnn.length());
            } else {
                cnn = "";
            }
            
            if ( cnn.length() == 1 ) {
                int arbic = isCNNumeric(cnn.charAt(0));
                if ( arbic <= 10 )
                    val += arbic * 10;
                cnn = "";
            }
        }
        
        shi = cnn.lastIndexOf('十');
        if ( shi > -1 ) {
            if ( shi == 0 ) {
                 val += 1 * 10;
            } else {
                val += cnNumericToArabic( cnn.substring(0, shi), false ) * 10;
            }
            
            if ( shi < cnn.length() - 1 ){
                cnn = cnn.substring(shi + 1, cnn.length());
            } else {
                cnn = "";
            }   
        }
        
        cnn = cnn.trim();
        for ( int j = 0; j < cnn.length(); j++ ) {
            val += isCNNumeric(cnn.charAt(j)) * Math.pow(10, cnn.length() - j - 1);
        }
        
        return val;
    }
291713
public static Double ceil(Double a) {
		return a==null ? null : Math.ceil(a);
	}
636575
public static double azimuth( Coordinate c1, Coordinate c2 ) {
        // vertical
        if (c1.x == c2.x) {
            if (c1.y == c2.y) {
                // same point
                return Double.NaN;
            } else if (c1.y < c2.y) {
                return 0.0;
            } else if (c1.y > c2.y) {
                return 180.0;
            }
        }
        // horiz
        if (c1.y == c2.y) {
            if (c1.x < c2.x) {
                return 90.0;
            } else if (c1.x > c2.x) {
                return 270.0;
            }
        }
        // -> /
        if (c1.x < c2.x && c1.y < c2.y) {
            double tanA = (c2.x - c1.x) / (c2.y - c1.y);
            double atan = atan(tanA);
            return toDegrees(atan);
        }
        // -> \
        if (c1.x < c2.x && c1.y > c2.y) {
            double tanA = (c1.y - c2.y) / (c2.x - c1.x);
            double atan = atan(tanA);
            return toDegrees(atan) + 90.0;
        }
        // <- /
        if (c1.x > c2.x && c1.y > c2.y) {
            double tanA = (c1.x - c2.x) / (c1.y - c2.y);
            double atan = atan(tanA);
            return toDegrees(atan) + 180;
        }
        // <- \
        if (c1.x > c2.x && c1.y < c2.y) {
            double tanA = (c2.y - c1.y) / (c1.x - c2.x);
            double atan = atan(tanA);
            return toDegrees(atan) + 270;
        }

        return Double.NaN;
    }
1078214
public static DZcsn cs_chol(DZcs A, DZcss S) {
		double[] d, lki ;
		DZcsa Lx = new DZcsa (), x, Cx = new DZcsa () ;
		int top, i, p, k, n, Li[], Lp[], cp[], pinv[], s[], c[], parent[], Cp[], Ci[] ;
		DZcs L, C, E ;
		DZcsn N ;
		if (!CS_CSC(A) || S == null || S.cp == null || S.parent == null) return (null) ;
		n = A.n ;
		N = new DZcsn () ;		/* allocate result */
		c = new int [2*n] ;		/* get int workspace */
		x = new DZcsa (n) ;		/* get complex workspace */
		cp = S.cp ; pinv = S.pinv ; parent = S.parent ;
		C = pinv != null ? cs_symperm (A, pinv, true) : A ;
		E = pinv != null ? C : null ;	/* E is alias for A, or a copy E=A(p,p) */
		if (N == null || c == null || x == null || C == null) return (cs_ndone (N, E, c, x, false)) ;
		s = c ;
		int s_offset = n ;
		Cp = C.p ; Ci = C.i ; Cx.x = C.x ;
		N.L = L = cs_spalloc (n, n, cp[n], true, false); /* allocate result */
		if (L == null) return (cs_ndone (N, E, c, x, false)) ;
		Lp = L.p ; Li = L.i ; Lx.x = L.x ;
		for (k = 0 ; k < n ; k++) Lp [k] = c [k] = cp [k] ;
		for (k = 0 ; k < n ; k++)	/* compute L(k,:) for L*L' = C */
		{
			/* --- Nonzero pattern of L(k,:) ------------------------------------ */
			top = cs_ereach (C, k, parent, s, s_offset, c) ;		/* find pattern of L(k,:) */
			x.set(k, cs_czero ()) ;					/* x (0:k) is now zero */
			for (p = Cp [k] ; p < Cp [k + 1] ; p++)			/* x = full(triu(C(:,k))) */
			{
				if (Ci [p] <= k) x.set(Ci [p], Cx.get(p)) ;
			}
			d = x.get(k) ;				/* d = C(k,k) */
			x.set(k, cs_czero ()) ;			/* clear x for k+1st iteration */
			/* --- Triangular solve --------------------------------------------- */
			for ( ; top < n ; top++)		/* solve L(0:k-1,0:k-1) * x = C(:,k) */
			{
				i = s [s_offset + top] ;	/* s [top..n-1] is pattern of L(k,:) */
				lki = cs_cdiv (x.get(i), Lx.get(Lp [i])) ; /* L(k,i) = x (i) / L(i,i) */
				x.set(i, cs_czero ()) ;		/* clear x for k+1st iteration */
				for (p = Lp [i] + 1 ; p < c [i] ; p++)
				{
					x.set(Li [p], cs_cminus (x.get(Li [p]), cs_cmult (Lx.get(p), lki))) ;
				}
				d = cs_cminus (d, cs_cmult (lki, cs_conj (lki))) ;	/* d = d - L(k,i)*L(k,i) */
				p = c [i]++ ;
				Li [p] = k ;			/* store L(k,i) in column i */
				Lx.set(p, cs_conj (lki)) ;
			}
			/* --- Compute L(k,k) ----------------------------------------------- */
			if (d[0] <= 0 || d[1] != 0)
				return (cs_ndone (N, E, c, x, false)) ;	/* not pos def */
			p = c [k]++ ;
			Li [p] = k ;				/* store L(k,k) = sqrt (d) in column k */
			Lx.set(p, cs_csqrt (d)) ;
		}
		Lp [n] = cp [n] ;				/* finalize L */
		return (cs_ndone (N, E, c, x, true)) ;		/* success: free E,s,x; return N */
	}
1096321
public static Dcsd cs_scc(Dcs A) {
        int n, i, k, b, nb = 0, top, xi[], pstack[], p[], r[], Ap[], ATp[], rcopy[], Blk[];
        Dcs AT;
        Dcsd D;
        if (!Dcs_util.CS_CSC(A))
            return (null); /* check inputs */
        n = A.n;
        Ap = A.p;
        D = Dcs_util.cs_dalloc(n, 0); /* allocate result */
        AT = Dcs_transpose.cs_transpose(A, false); /* AT = A' */
        xi = new int[2 * n + 1]; /* get workspace */
        if (D == null || AT == null)
            return (null);
        Blk = xi;
        rcopy = xi;
        int rcopy_offset = n;
        pstack = xi;
        int pstack_offset = n;
        p = D.p;
        r = D.r;
        ATp = AT.p;
        top = n;
        for (i = 0; i < n; i++) /* first dfs(A) to find finish times (xi) */
        {
            if (!Dcs_util.CS_MARKED(Ap, i))
                top = Dcs_dfs.cs_dfs(i, A, top, xi, 0, pstack, pstack_offset, null, 0);
        }
        for (i = 0; i < n; i++)
            Dcs_util.CS_MARK(Ap, i); /* restore A; unmark all nodes*/
        top = n;
        nb = n;
        for (k = 0; k < n; k++) /* dfs(A') to find strongly connnected comp */
        {
            i = xi[k]; /* get i in reverse order of finish times */
            if (Dcs_util.CS_MARKED(ATp, i))
                continue; /* skip node i if already ordered */
            r[nb--] = top; /* node i is the start of a component in p */
            top = Dcs_dfs.cs_dfs(i, AT, top, p, 0, pstack, pstack_offset, null, 0);
        }
        r[nb] = 0; /* first block starts at zero; shift r up */
        for (k = nb; k <= n; k++)
            r[k - nb] = r[k];
        D.nb = nb = n - nb; /* nb = # of strongly connected components */
        for (b = 0; b < nb; b++) /* sort each block in natural order */
        {
            for (k = r[b]; k < r[b + 1]; k++)
                Blk[p[k]] = b;
        }
        for (b = 0; b <= nb; b++)
            rcopy[rcopy_offset + b] = r[b];
        for (i = 0; i < n; i++)
            p[rcopy[rcopy_offset + Blk[i]]++] = i;
        return D;
    }
72757
public static Scsd cs_scc(Scs A) {
        int n, i, k, b, nb = 0, top, xi[], pstack[], p[], r[], Ap[], ATp[], rcopy[], Blk[];
        Scs AT;
        Scsd S;
        if (!Scs_util.CS_CSC(A))
            return (null); /* check inputs */
        n = A.n;
        Ap = A.p;
        S = Scs_util.cs_dalloc(n, 0); /* allocate result */
        AT = Scs_transpose.cs_transpose(A, false); /* AT = A' */
        xi = new int[2 * n + 1]; /* get workspace */
        if (S == null || AT == null)
            return (null);
        Blk = xi;
        rcopy = xi;
        int rcopy_offset = n;
        pstack = xi;
        int pstack_offset = n;
        p = S.p;
        r = S.r;
        ATp = AT.p;
        top = n;
        for (i = 0; i < n; i++) /* first dfs(A) to find finish times (xi) */
        {
            if (!Scs_util.CS_MARKES(Ap, i))
                top = Scs_dfs.cs_dfs(i, A, top, xi, 0, pstack, pstack_offset, null, 0);
        }
        for (i = 0; i < n; i++)
            Scs_util.CS_MARK(Ap, i); /* restore A; unmark all nodes*/
        top = n;
        nb = n;
        for (k = 0; k < n; k++) /* dfs(A') to find strongly connnected comp */
        {
            i = xi[k]; /* get i in reverse order of finish times */
            if (Scs_util.CS_MARKES(ATp, i))
                continue; /* skip node i if already ordered */
            r[nb--] = top; /* node i is the start of a component in p */
            top = Scs_dfs.cs_dfs(i, AT, top, p, 0, pstack, pstack_offset, null, 0);
        }
        r[nb] = 0; /* first block starts at zero; shift r up */
        for (k = nb; k <= n; k++)
            r[k - nb] = r[k];
        S.nb = nb = n - nb; /* nb = # of strongly connected components */
        for (b = 0; b < nb; b++) /* sort each block in natural order */
        {
            for (k = r[b]; k < r[b + 1]; k++)
                Blk[p[k]] = b;
        }
        for (b = 0; b <= nb; b++)
            rcopy[rcopy_offset + b] = r[b];
        for (i = 0; i < n; i++)
            p[rcopy[rcopy_offset + Blk[i]]++] = i;
        return S;
    }
616244
def cnst_AT(self, X):
        
        """

        return np.sum(np.concatenate(
            [sl.GTax(X[..., ax], ax)[..., np.newaxis] for ax in self.axes],
            axis=X.ndim-1), axis=X.ndim-1)