Examples of IndexGenerator

cc.redberry.core.indexgenerator.IndexGenerator
Generates distinct indices of particular types, which does not contain in specified sets of indices (engaged data). @author Dmitry Bolotin @author Stanislav Poslavsky @since 1.0

Examples of cc.redberry.core.indexgenerator.IndexGenerator

        System.arraycopy(allForbidden, 0, forbiddenGeneratorIndices, 0, allForbidden.length);
        i = allForbidden.length - 1;
        for (Integer index : dummyIndices)
            forbiddenGeneratorIndices[++i] = index;


        IndexGenerator generator = new IndexGenerator(forbiddenGeneratorIndices);//also sorts allForbidden array
        for (Integer index : dummyIndices)
            if (Arrays.binarySearch(allForbidden, index) >= 0 && Arrays.binarySearch(from, index) < 0) {
                fromL.add(index);
                toL.add(generator.generate(IndicesUtils.getType(index)));
            }


        int[] _from = fromL.toArray(), _to = toL.toArray();
        ArraysUtils.quickSort(_from, _to);

View Full Code Here

Examples of cc.redberry.core.indexgenerator.IndexGenerator


        private final IndexGenerator generator;
        private final Map<Integer, Integer> map;


        public IndexMapper(int[] initialUsed) {
            generator = new IndexGenerator(initialUsed);
            map = new HashMap<>(initialUsed.length);
        }

View Full Code Here

Examples of cc.redberry.core.indexgenerator.IndexGenerator


        //Creating indices for Indices instances
        int[] _freeIndices = indices.getFree().getAllIndices().copy();
        int[][] freeIndices = new int[TYPES.length][];
        int[][] indicesSpace = new int[TYPES.length][];
        IndexGenerator indexGenerator = new IndexGenerator(_freeIndices.clone());
        for (byte b : TYPES) {
            indicesSpace[b] = new int[totalIndicesCounts[b]];
            IndicesTypeStructure.TypeData typeData = typeStructure.getTypeData(b);
            if (typeData == null)
                freeIndices[b] = new int[0];
            else {
                freeIndices[b] = new int[typeData.length];
                System.arraycopy(_freeIndices, typeData.from, freeIndices[b], 0, typeData.length);
            }
            int diff = (totalIndicesCounts[b] - freeIndices[b].length) / 2;
            for (i = 0; i < diff; ++i)
                indicesSpace[b][i] = indexGenerator.generate(b);
            for (i = 0; i < diff; ++i)
                indicesSpace[b][i + diff] = IndicesUtils.inverseIndexState(indicesSpace[b][i]);
            System.arraycopy(freeIndices[b], 0, indicesSpace[b], diff * 2, freeIndices[b].length);
            shuffle(indicesSpace[b]);
        }

View Full Code Here

Examples of cc.redberry.core.indexgenerator.IndexGenerator


        //Creating indices for Indices instances
        int[] _freeIndices = indices.getFree().getAllIndices().copy();
        int[][] freeIndices = new int[TYPES.length][];
        int[][] indicesSpace = new int[TYPES.length][];
        IndexGenerator indexGenerator = new IndexGenerator(_freeIndices.clone());
        for (byte b : TYPES) {
            indicesSpace[b] = new int[totalIndicesCounts[b]];
            StructureOfIndices.TypeData typeData = typeStructure.getTypeData(b);
            if (typeData == null)
                freeIndices[b] = new int[0];
            else {
                freeIndices[b] = new int[typeData.length];
                System.arraycopy(_freeIndices, typeData.from, freeIndices[b], 0, typeData.length);
            }
            int diff = (totalIndicesCounts[b] - freeIndices[b].length) / 2;
            for (i = 0; i < diff; ++i)
                indicesSpace[b][i] = indexGenerator.generate(b);
            for (i = 0; i < diff; ++i)
                indicesSpace[b][i + diff] = IndicesUtils.inverseIndexState(indicesSpace[b][i]);
            System.arraycopy(freeIndices[b], 0, indicesSpace[b], diff * 2, freeIndices[b].length);
            shuffle(indicesSpace[b]);
        }

View Full Code Here

Examples of cc.redberry.core.indexgenerator.IndexGenerator

        for (Integer f : dummyIndices)
            forbidden[++i] = f;
        System.arraycopy(upperLower, 0, forbidden, dummyIndices.size(), upperLower.length);




        IndexGenerator generator = new IndexGenerator(forbidden);
        IntArrayList from = new IntArrayList(), to = new IntArrayList();
        int fromIndex;
        for (i = upperLower.length - 1; i >= 0; --i) {
            fromIndex = upperLower[i];
            if (dummyIndices.contains(fromIndex)) {
                from.add(fromIndex);
                to.add(generator.generate(IndicesUtils.getType(fromIndex)));
            }
        }


        int[] _from = from.toArray(), _to = to.toArray();
        ArraysUtils.quickSort(_from, _to);

View Full Code Here

Examples of cc.redberry.core.indexgenerator.IndexGenerator


    private static SimpleTensor setDiffIndices(SimpleTensor eps) {
        byte type = getType(eps.getIndices().get(0));
        int count = eps.getIndices().size();
        int[] newIndices = new int[count];
        IndexGenerator generator = new IndexGenerator(eps.getIndices());
        for (int i = 0; i < count; ++i)
            newIndices[i] = generator.generate(type);
        return Tensors.simpleTensor(eps.getName(), IndicesFactory.createSimple(null, newIndices));
    }

View Full Code Here

Examples of cc.redberry.core.indexgenerator.IndexGenerator

        CacheContainer cacheContainer = new CacheContainer(sunName, fName, dName, N);
        Expression[] expressions = cachedSubstitutions.get(cacheContainer);
        if (expressions != null)
            return expressions;
        List<Expression> expressionsList = new ArrayList<>();
        IndexGenerator generator = new IndexGenerator();


        //creating  T_a*T_b  = 1/2N g_ab + I/2*f_abc*T^c + 1/2*d_abc*T^c
        int upper, lower, contracted, firstMetric, secondMetric, thirdMetric;
        SimpleIndices indicesOfA = IndicesFactory.createSimple(null,
                firstMetric = generator.generate(metricType),
                upper = (0x80000000 | generator.generate(matrixType)),
                contracted = generator.generate(matrixType));


        SimpleIndices indicesOfB = IndicesFactory.createSimple(null,
                secondMetric = generator.generate(metricType),
                (0x80000000 | contracted),
                lower = generator.generate(matrixType));


        SimpleIndices indicesOfC = IndicesFactory.createSimple(null,
                (0x80000000 | (thirdMetric = generator.generate(metricType))),
                upper, lower);


        Tensor lhs = multiply(simpleTensor(sunName, indicesOfA),
                simpleTensor(sunName, indicesOfB));


        //(1/(2*N))*g_ab
        Tensor gTerm = multiply(Complex.ONE_HALF, reciprocal(N),
                createMetric(firstMetric, secondMetric), createKronecker(upper, lower));


        SimpleIndices fIndices = IndicesFactory.createSimple(null, firstMetric, secondMetric, thirdMetric);
        Tensor C = simpleTensor(sunName, indicesOfC);
        //(I/2)*f_abc*T^c
        Tensor fTerm = multiply(Complex.ONE_HALF, Complex.IMAGE_ONE,
                simpleTensor(fName, fIndices), C);
        //(1/2)*d_abc*T^c
        Tensor dTerm = multiply(Complex.ONE_HALF,
                simpleTensor(dName, fIndices), C);


        expressionsList.add(expression(lhs, sum(gTerm, fTerm, dTerm)));


        //creating Tr[T] = 0
        indicesOfA = IndicesFactory.createSimple(null, firstMetric, (0x80000000 | contracted), contracted);
        expressionsList.add(expression(simpleTensor(sunName, indicesOfA), Complex.ZERO));


        //creating d_apq*d_b^pq = (N**2 - 4)/N * g_ab
        indicesOfA = IndicesFactory.createSimple(null,
                upper = generator.generate(metricType),
                firstMetric = generator.generate(metricType),
                secondMetric = generator.generate(metricType));
        indicesOfB = IndicesFactory.createSimple(null,
                lower = generator.generate(metricType),
                (0x80000000 | firstMetric),
                (0x80000000 | secondMetric));


        lhs = multiply(simpleTensor(dName, indicesOfA), simpleTensor(dName, indicesOfB));
        Tensor rhs = multiply(reciprocal(N), subtract(pow(N, 2), Complex.FOUR), createMetric(upper, lower));

View Full Code Here

Examples of cc.redberry.core.indexgenerator.IndexGenerator

        Key key = new Key(gammaName, gammasCount, metricType, matrixType);
        SubstitutionTransformation sub = cache.get(key);
        if (sub != null)
            return sub;
        Tensor[] gammas = new Tensor[gammasCount];
        IndexGenerator generator = new IndexGenerator();
        int firstUpper, u = firstUpper = generator.generate(matrixType), i;
        for (i = 0; i < gammasCount; ++i) {
            gammas[i] = Tensors.simpleTensor(gammaName,
                    createSimple(null,
                            u | 0x80000000,
                            i == gammasCount - 1 ? firstUpper : (u = generator.generate(matrixType)),
                            generator.generate(metricType)));


        }
        sub = new SubstitutionTransformation(Tensors.multiply(gammas), traceOfArray(gammas, metricType));
        cache.put(key, sub);
        return sub;

View Full Code Here

Examples of cc.redberry.core.indexgenerator.IndexGenerator


        //building index generator
        IntArrayList usedIndices = new IntArrayList(TensorUtils.getAllIndicesNames(split.factoredOut));
        usedIndices.addAll(factorsIndicesNames);
        usedIndices.addAll(termIndicesNames);
        IndexGenerator ig = new IndexGenerator(usedIndices.toArray());


        List<Tensor> mkCollectedList = new ArrayList<>();


        for (Map.Entry<Integer, IndexMappingBufferRecord> entry : concurentBuffer.getMap().entrySet()) {


            int indexCollected, indexToCollect, rawState = ((entry.getValue().getStates() & 1) ^ 1) << 31;
            boolean diffStatesInit = entry.getValue().diffStatesInitialized();
            indexCollected = rawState | entry.getValue().getIndexName();
            indexToCollect = (diffStatesInit ? 0x80000000 : 0) ^ (rawState | entry.getKey());


            SimpleTensor mkCollected;
            SimpleTensor mkToCollect;


            if (indexToCollect == indexCollected)
                continue;
            else if (uncontractedIndicesToCollect.contains(getNameWithType(indexToCollect))
                    && uncontractedIndicesCollected.contains(getNameWithType(indexCollected)))
                mappingToCollect.add(inverseIndexState(indexToCollect),
                        inverseIndexState(indexCollected));
            else if (uncontractedIndicesToCollect.contains(getNameWithType(indexToCollect))) {
                mkCollected = CC.createMetricOrKronecker(inverseIndexState(indexToCollect), indexCollected);


                factorsIndicesNames.add(getNameWithType(indexCollected));
                factorsIndicesNames.add(getNameWithType(indexToCollect));


                termIndicesNames.replaceFirst(getNameWithType(indexCollected), getNameWithType(indexToCollect));
                mappingCollectedTensor.add(indexCollected, indexToCollect);
                mkCollectedList.add(mkCollected);
            } else if (uncontractedIndicesCollected.contains(getNameWithType(indexCollected))) {
                mkToCollect = CC.createMetricOrKronecker(indexToCollect, inverseIndexState(indexCollected));
                split.factoredOut.add(mkToCollect);
            } else {
                int newIndex = ig.generate(getType(indexToCollect));
                factorsIndicesNames.add(getNameWithType(indexCollected));
                factorsIndicesNames.add(newIndex);
                termIndicesNames.replaceFirst(getNameWithType(indexCollected), newIndex);


                newIndex = getRawStateInt(indexCollected) | newIndex;

View Full Code Here

Examples of cc.redberry.core.indexgenerator.IndexGenerator

            SimpleIndices varIndices = var.getIndices();
            int[] allFreeVarIndices = new int[varIndices.size()];
            int[] allFreeArgIndices = new int[varIndices.size()];
            byte type;
            int state, i = 0, length = allFreeArgIndices.length;
            IndexGenerator indexGenerator = new IndexGenerator(varIndices);
            for (; i < length; ++i) {
                type = getType(varIndices.get(i));
                state = getRawStateInt(varIndices.get(i));
                allFreeVarIndices[i] = setRawState(indexGenerator.generate(type), inverseIndexState(state));
                allFreeArgIndices[i] = setRawState(indexGenerator.generate(type), state);
            }
            int[] allIndices = addAll(allFreeVarIndices, allFreeArgIndices);
            SimpleIndices dIndices = IndicesFactory.createSimple(null, allIndices);
            SimpleTensor symmetric = simpleTensor("@!@#@##_AS@23@@#", dIndices);
            Tensor derivative = SymmetrizeSimpleTensorTransformation.symmetrize(

View Full Code Here

0 1 2 3 4

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.