Examples of cc.redberry.core.combinatorics.symmetries.Symmetries

Package cc.redberry.core.combinatorics.symmetries

Examples of cc.redberry.core.combinatorics.symmetries.Symmetries

cc.redberry.core.combinatorics.symmetries.Symmetries

This interface is a representation of a set of symmetries, which takes into account possible compositions of symmetries in this set. More formally, set contains no element s, which can be expressed as s=s1*s2*s3*...*sN, where {s1,s2,s3,...,sN} are elements of this set. So, this interface models the mathematical basis of subgroup of symmetric group. It contains the identity symmetry by default.

All symmetries, keeping by this set must be consistent. It means, that all of them must have similar dimension (see {@link #dimension()}); next, if we denote symmetry as pair (permutation, sign), there is no any symmetry (p,s) and subset of symmetries {(p1,s1),(p2,s2),...,<(pN,sN)}, such that p = p1*p2*p3*...*pN, but s != s1*s2*s3*...*sN. Method {@link #add(cc.redberry.core.combinatorics.Symmetry)} throws {@link InconsistentGeneratorsException}if its argument is inconsistent with existing symmetries in set.

Iterator returned by this set iterates over all possible compositions of symmetries from set, i.e. it works as {@link PermutationsSpanIterator}. To extract only the basis symmetries, a special method {@link #getBasisSymmetries() }introduced. This method returns an unmodifiable list of basis symmetries.

Objects of this type can be created via static factory methods in {@link SymmetriesFactory}.
@author Dmitry Bolotin @author Stanislav Poslavsky @see SymmetriesFactory @see Symmetry @see PermutationsSpanIterator @see InconsistentGeneratorsException

    public static Symmetry getSymmetryFromMapping(final int[] indices, IndexMappingBuffer indexMappingBuffer) {
        return getSymmetryFromMapping1(IndicesUtils.getIndicesNames(indices), indexMappingBuffer);
    }


    public static Symmetries getSymmetriesFromMappings(final int[] indices, MappingsPort mappingsPort) {
        Symmetries symmetries = SymmetriesFactory.createSymmetries(indices.length);
        int[] indicesNames = IndicesUtils.getIndicesNames(indices);
        IndexMappingBuffer buffer;
        while ((buffer = mappingsPort.take()) != null)
            symmetries.add(getSymmetryFromMapping1(indicesNames, buffer));
        return symmetries;
    }

View Full Code Here

    public static Symmetries findIndicesSymmetries(SimpleIndices indices, Tensor tensor) {
        return getSymmetriesFromMappings(indices.getAllIndices().copy(), IndexMappings.createPort(tensor, tensor));
    }


    public static Symmetries getIndicesSymmetriesForIndicesWithSameStates(final int[] indices, Tensor tensor) {
        Symmetries total = findIndicesSymmetries(indices, tensor);
        Symmetries symmetries = SymmetriesFactory.createSymmetries(indices.length);
        int i;
        OUT:
        for (Symmetry s : total) {
            for (i = 0; i < indices.length; ++i)
                if (IndicesUtils.getRawStateInt(indices[i]) != IndicesUtils.getRawStateInt(indices[s.newIndexOf(i)]))
                    continue OUT;
            symmetries.add(s);
        }
        return symmetries;
    }

View Full Code Here

    public static Symmetry getSymmetryFromMapping(final int[] indices, IndexMappingBuffer indexMappingBuffer) {
        return getSymmetryFromMapping1(IndicesUtils.getIndicesNames(indices), indexMappingBuffer);
    }


    public static Symmetries getSymmetriesFromMappings(final int[] indices, MappingsPort mappingsPort) {
        Symmetries symmetries = SymmetriesFactory.createSymmetries(indices.length);
        int[] indicesNames = IndicesUtils.getIndicesNames(indices);
        IndexMappingBuffer buffer;
        while ((buffer = mappingsPort.take()) != null)
            symmetries.add(getSymmetryFromMapping1(indicesNames, buffer));
        return symmetries;
    }

View Full Code Here

    private static Map<IntArray, Boolean> getEpsilonSymmetries(int indicesSize) {
        Map<IntArray, Boolean> symmetries = cachedLeviCivitaSymmetries.get(indicesSize);
        if (symmetries != null)
            return symmetries;
        symmetries = new HashMap<>();
        Symmetries ss = SymmetriesFactory.createSymmetries(indicesSize);
        ss.addUnsafe(new Symmetry(Combinatorics.createTransposition(indicesSize, 0, 1), true));
        if (indicesSize % 2 == 0)
            ss.addUnsafe(new Symmetry(Combinatorics.createCycle(indicesSize), true));
        else
            ss.addUnsafe(new Symmetry(Combinatorics.createCycle(indicesSize), false));
        for (Symmetry symmetry : ss)
            symmetries.put(symmetry.getPermutation(), symmetry.isAntiSymmetry());
        cachedLeviCivitaSymmetries.put(indicesSize, symmetries);
        return symmetries;
    }

View Full Code Here

    }


    public static Tensor symmetrizeUpperLowerIndices(Tensor tensor, boolean multiplyOnSymmetryFactor) {
        Indices indices = IndicesFactory.create(tensor.getIndices().getFree());
        int[] indicesArray = indices.getAllIndices().copy();
        Symmetries symmetries = TensorUtils.getIndicesSymmetriesForIndicesWithSameStates(indicesArray, tensor);
        int lowerCount = indices.getLower().length(), upperCount = indices.getUpper().length();


        IntPermutationsGenerator lowIndicesPermutationsGenerator,
                upperIndicesPermutationGenerator;
        SumBuilder sumBuilder = new SumBuilder();

View Full Code Here

        int[] _sortPermutation = ArraysUtils.quickSortP(sortedIndicesNames);
        return getSymmetryFromMapping1(sortedIndicesNames, _sortPermutation, mapping);
    }


    public static Symmetries getSymmetriesFromMappings(final int[] indices, MappingsPort mappingsPort) {
        Symmetries symmetries = SymmetriesFactory.createSymmetries(indices.length);
        int[] sortedIndicesNames = IndicesUtils.getIndicesNames(indices);
        int[] sortPermutation = ArraysUtils.quickSortP(sortedIndicesNames);
        Mapping buffer;
        while ((buffer = mappingsPort.take()) != null)
            symmetries.add(getSymmetryFromMapping1(sortedIndicesNames, sortPermutation, buffer));
        return symmetries;
    }

View Full Code Here

    public static Symmetries findIndicesSymmetries(SimpleIndices indices, Tensor tensor) {
        return getSymmetriesFromMappings(indices.getAllIndices().copy(), IndexMappings.createPort(tensor, tensor));
    }


    public static Symmetries getIndicesSymmetriesForIndicesWithSameStates(final int[] indices, Tensor tensor) {
        Symmetries total = findIndicesSymmetries(indices, tensor);
        Symmetries symmetries = SymmetriesFactory.createSymmetries(indices.length);
        int i;
        OUT:
        for (Symmetry s : total) {
            for (i = 0; i < indices.length; ++i)
                if (IndicesUtils.getRawStateInt(indices[i]) != IndicesUtils.getRawStateInt(indices[s.newIndexOf(i)]))
                    continue OUT;
            symmetries.add(s);
        }
        return symmetries;
    }

View Full Code Here

        ArraysUtils.stableSort(types, cosort);
        int[] cosortInv = Combinatorics.inverse(cosort);


        //Allocating resulting symmetries object
        //it already contains identity symmetry
        Symmetries resultingSymmetries =
                SymmetriesFactory.createSymmetries(data.length);


        int[] c;
        int position = 0, k;


        //rescaling symmetries to the actual length and positions corresponding
        //to the sorted indices
        for (Symmetries ss : this.symmetries) {
            final List<Symmetry> basis = ss.getBasisSymmetries();
            //iterating from 1 because zero'th element is always identity symmetry 
            for (k = 1; k < basis.size(); ++k) {
                c = new int[data.length];
                Symmetry s = basis.get(k);
                for (j = 0; j < data.length; ++j)
                    if (cosort[j] < position || cosort[j] >= position + s.dimension())
                        c[j] = j;
                    else
                        c[j] = cosortInv[s.newIndexOf(cosort[j] - position) + position];
                resultingSymmetries.addUnsafe(UnsafeCombinatorics.createUnsafe(c, s.isAntiSymmetry()));
            }
            //increasing position in the total symmetry array
            position += ss.dimension();
        }

View Full Code Here

    private static Map<IntArray, Boolean> getEpsilonSymmetries(int indicesSize) {
        Map<IntArray, Boolean> symmetries = cachedLeviCivitaSymmetries.get(indicesSize);
        if (symmetries != null)
            return symmetries;
        symmetries = new HashMap<>();
        Symmetries ss = SymmetriesFactory.createSymmetries(indicesSize);
        ss.addUnsafe(new Symmetry(Combinatorics.createTransposition(indicesSize, 0, 1), true));
        if (indicesSize % 2 == 0)
            ss.addUnsafe(new Symmetry(Combinatorics.createCycle(indicesSize), true));
        else
            ss.addUnsafe(new Symmetry(Combinatorics.createCycle(indicesSize), false));
        for (Symmetry symmetry : ss)
            symmetries.put(symmetry.getPermutation(), symmetry.isAntiSymmetry());
        cachedLeviCivitaSymmetries.put(indicesSize, symmetries);
        return symmetries;
    }

View Full Code Here

    public static Symmetry getSymmetryFromMapping(final int[] indices, IndexMappingBuffer indexMappingBuffer) {
        return getSymmetryFromMapping1(IndicesUtils.getIndicesNames(indices), indexMappingBuffer);
    }


    public static Symmetries getSymmetriesFromMappings(final int[] indices, MappingsPort mappingsPort) {
        Symmetries symmetries = SymmetriesFactory.createSymmetries(indices.length);
        int[] indicesNames = IndicesUtils.getIndicesNames(indices);
        IndexMappingBuffer buffer;
        while ((buffer = mappingsPort.take()) != null)
            symmetries.add(getSymmetryFromMapping1(indicesNames, buffer));
        return symmetries;
    }

View Full Code Here

0 1 2

TOP

Related Classes of cc.redberry.core.combinatorics.symmetries.Symmetries

cc.redberry.core.indices.SimpleIndicesBuilder

cc.redberry.core.transformations.symmetrization.Symmetrize

cc.redberry.core.transformations.symmetrization.SymmetrizeUpperLowerIndicesTransformation

cc.redberry.core.utils.TensorUtils

cc.redberry.physics.feyncalc.LeviCivitaSimplify

cc.redberry.physics.feyncalc.LeviCivitaSimplifyTransformation

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.