Examples of cc.redberry.core.indices.SimpleIndices

cc.redberry.core.indices.SimpleIndices

This interface states additional functionality of the indices of the {@link SimpleTensor}. Indices of this type stores not only set of indices but also their order and symmetries.

To create objects of this type use {@link IndicesFactory#createSimple(IndicesSymmetries,int)}.
@author Dmitry Bolotin @author Stanislav Poslavsky @see Indices @see IndicesFactory

    @Override
    public IndexMappingBuffer take() {
        if (currentBuffer == null)
            return null;


        SimpleIndices fromIndices = from.getIndices();
        SimpleIndices toIndices = to.getIndices();
        int size = fromIndices.size();
        if (size == 0) {
            IndexMappingBuffer r = currentBuffer;
            currentBuffer = null;
            return r;
        }


        if (symmetryIterator != null) {
            OUT:
            while (symmetryIterator.hasNext()) {
                Symmetry s = symmetryIterator.next();
                IndexMappingBuffer tempBuffer = currentBuffer.clone();
                for (int i = 0; i < size; ++i)
                    if (!tempBuffer.tryMap(fromIndices.get(s.newIndexOf(i)), toIndices.get(i)))
                        continue OUT;
                tempBuffer.addSign(s.isAntiSymmetry());
                return tempBuffer;
            }
            symmetryIterator = null;
            currentBuffer = null;
            return null;
        }
        if (fromIndices.getSymmetries().isEmpty()) {
            IndexMappingBuffer tempBuffer = currentBuffer;
            for (int i = 0; i < size; ++i)
                if (!tempBuffer.tryMap(fromIndices.get(i), toIndices.get(i))) {
                    currentBuffer = null;
                    return null;
                }
            currentBuffer = null;
            return tempBuffer;

View Full Code Here

    }


    public static Tensor applyIndexMapping(Tensor tensor, IndexMapper mapper) {
        TreeTraverseIterator iterator = new TreeTraverseIterator(tensor, TraverseGuide.EXCEPT_FUNCTIONS_AND_FIELDS);
        TraverseState state;
        SimpleIndices oldIndices, newIndices;
        SimpleTensor simpleTensor;
        while ((state = iterator.next()) != null) {
            if (state == TraverseState.Leaving)
                continue;
            if (!(iterator.current() instanceof SimpleTensor))
                continue;
            simpleTensor = (SimpleTensor) iterator.current();
            oldIndices = simpleTensor.getIndices();
            newIndices = oldIndices.applyIndexMapping(mapper);
            if (oldIndices != newIndices)
                if (simpleTensor instanceof TensorField)
                    iterator.set(Tensors.setIndicesToField((TensorField) simpleTensor, newIndices));
                else
                    iterator.set(Tensors.setIndicesToSimpleTensor(simpleTensor, newIndices));

View Full Code Here

    }


    private static Tensor renameDummy(Tensor tensor, IndexMapper mapper) {
        TreeTraverseIterator iterator = new TreeTraverseIterator(tensor);
        TraverseState state;
        SimpleIndices oldIndices, newIndices;
        SimpleTensor simpleTensor;
        while ((state = iterator.next()) != null) {
            if (state != TraverseState.Leaving)
                continue;


            if (!(iterator.current() instanceof SimpleTensor))
                continue;
            simpleTensor = (SimpleTensor) iterator.current();
            oldIndices = simpleTensor.getIndices();
            newIndices = oldIndices.applyIndexMapping(mapper);
            if (oldIndices != newIndices)
                if (simpleTensor instanceof TensorField)
                    iterator.set(Tensors.setIndicesToField((TensorField) simpleTensor, newIndices));
                else
                    iterator.set(Tensors.setIndicesToSimpleTensor(simpleTensor, newIndices));

View Full Code Here

                return res;
            return Integer.compare(indices[1], o.indices[1]);
        }


        SimpleTensor apply(SimpleTensor t) {
            SimpleIndices oldIndices = t.getIndices();
            int from = -1, to = -1;
            OUTER:
            for (int i = 0; i < oldIndices.size(); ++i)
                for (int j = 0; j < 2; ++j)
                    if ((oldIndices.get(i) ^ indices[j])
                            == 0x80000000) {
                        from = oldIndices.get(i);
                        to = indices[1 - j];
                        break OUTER;
                    }
            IM im = new IM(from, to);
            SimpleIndices newIndices = oldIndices.applyIndexMapping(im);
            if (oldIndices == newIndices)
                return t;
            return Tensors.simpleTensor(t.getName(), newIndices);
        }

View Full Code Here

                return res;
            return Integer.compare(indices[1], o.indices[1]);
        }


        SimpleTensor apply(SimpleTensor t) {
            SimpleIndices oldIndices = t.getIndices();
            int from = -1, to = -1;
            OUTER:
            for (int i = 0; i < oldIndices.size(); ++i)
                for (int j = 0; j < 2; ++j)
                    if ((oldIndices.get(i) ^ indices[j])
                            == 0x80000000) {
                        from = oldIndices.get(i);
                        to = indices[1 - j];
                        break OUTER;
                    }
            IM im = new IM(from, to);
            SimpleIndices newIndices = oldIndices.applyIndexMapping(im);
            if (oldIndices == newIndices)
                return t;
            if (t.getClass() == SimpleTensor.class)
                return Tensors.simpleTensor(t.getName(), newIndices);
            TensorField ff = (TensorField) t;

View Full Code Here

            this.node = node;
        }


        @Override
        public void apply(IndexMapper indexMapper, IGWrapper generator, int[] upper, int[] lower) {
            SimpleIndices oldIndices = node.indices;
            int[] _newIndices = new int[oldIndices.size() + 2 * upper.length];
            int i;
            for (i = 0; i < oldIndices.size(); ++i)
                _newIndices[i] = indexMapper.map(oldIndices.get(i));
            System.arraycopy(upper, 0, _newIndices, oldIndices.size(), upper.length);
            System.arraycopy(lower, 0, _newIndices, oldIndices.size() + upper.length, lower.length);
            for (i = 0; i < upper.length; ++i)
                _newIndices[i + oldIndices.size()] |= 0x80000000;
            node.indices = IndicesFactory.createSimple(null, _newIndices);
        }

View Full Code Here

    private TensorHashCalculator() {
    }


    private static int _hashWithIndices(final Tensor tensor, final int[] indices) {
        if (tensor instanceof SimpleTensor) {
            SimpleIndices si = ((SimpleTensor) tensor).getIndices();
            short[] sInds = si.getDiffIds();
            int hash = tensor.hashCode();
            int pos;
            for (int i = 0; i < si.size(); ++i)
                if ((pos = Arrays.binarySearch(indices, si.get(i))) >= 0)
                    hash += (HashFunctions.JenkinWang32shift(sInds[i])
                            * HashFunctions.JenkinWang32shift(pos) * 7);
            return HashFunctions.JenkinWang32shift(hash);
        }
        if (tensor instanceof ScalarFunction)

View Full Code Here

        }
        return iterator.result();
    }


    private static void checkLeviCivita(SimpleTensor LeviCivita) {
        SimpleIndices indices = LeviCivita.getIndices();
        if (indices.size() <= 1)
            throw new IllegalArgumentException("Levi-Civita cannot be a scalar.");
        byte type = getType(indices.get(0));
        for (int i = 1; i < indices.size(); ++i)
            if (type != getType(indices.get(i)))
                throw new IllegalArgumentException("Levi-Civita have indices with different types.");
    }

View Full Code Here

    public static Expression[] getLeviCivitaSubstitutions(SimpleTensor eps) {
        Expression[] sub = cachedSubstitutions.get(eps.getName());
        if (sub != null)
            return sub;
        sub = new Expression[2];
        SimpleIndices indices = eps.getIndices();
        int size = indices.size();


        SimpleTensor eps1 = setDiffIndices(eps),
                eps2 = setInversedIndices(setDiffIndices(eps1));
        Tensor lhs = multiply(eps1, eps2);
        SimpleIndices eps1Indices = eps1.getIndices(),
                eps2Indices = eps2.getIndices();
        Tensor[][] matrix = new Tensor[size][size];
        int j;
        for (int i = 0; i < size; ++i)
            for (j = 0; j < size; ++j)
                matrix[i][j] = createKronecker(eps1Indices.get(i), eps2Indices.get(j));


        Tensor rhs = TensorUtils.det(matrix);
        //todo here we assuming, that all indices belongs to pseudo-Euclidean spaces
        if (size % 2 == 0)
            rhs = negate(rhs);
        sub[0] = expression(lhs, rhs);
        int index = eps1Indices.get(0);
        sub[1] = expression(createKronecker(index, inverseIndexState(index)), new Complex(size));
        cachedSubstitutions.put(eps.getName(), sub);
        return sub;
    }

View Full Code Here

        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

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of cc.redberry.core.indices.SimpleIndices

cc.redberry.core.indexmapping.ProviderSimpleTensor

cc.redberry.core.parser.ParserSimpleTensor

cc.redberry.core.parser.ParserTensorField

cc.redberry.core.parser.preprocessor.IndicesInsertion$SimpleTransformer

cc.redberry.core.solver.ReduceEngine

cc.redberry.core.tensor.ApplyIndexMapping

cc.redberry.core.tensor.random.RandomProduct

cc.redberry.core.tensor.SimpleTensor

cc.redberry.core.transformations.ApplyIndexMapping

cc.redberry.core.transformations.collect.CollectTransformation

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.