Examples of cc.redberry.core.utils.IntArrayList

cc.redberry.core.utils.IntArrayList
Array list of primitive integers. @author Dmitry Bolotin @author Stanislav Poslavsky

        if (degree == 0)
            return Collections.EMPTY_LIST;


        // first, lets remove unnecessary base points, i.e. such points, that are fixed by all generators


        IntArrayList base = new IntArrayList(knownBase.clone());


        //we try to find such a point that is not fixed at least by one of the generators
        out:
        for (int i = base.size() - 1; i >= 0; --i) {
            for (Permutation permutation : generators)
                if (permutation.newIndexOf(base.get(i)) != base.get(i))
                    continue out;
            base.remove(i);
        }


        if (base.isEmpty()) {
            //there is no any point that is not fixed by all generators, i.e. all generators fixes all points in the specified base
            //all that's left is to try to find a base
            return createRawBSGSCandidate(generators, degree);
        }




        ArrayList<BSGSCandidateElement> BSGS = new ArrayList<>(knownBase.length);
        // corresponding G^(i) is G^(0) = G, so its stabilizer generators (stabilizes zero points)
        // are just generators of group
        BSGS.add(new BSGSCandidateElement(base.get(0), new ArrayList<>(generators), degree));
        for (int i = 1, size = base.size(); i < size; ++i) {
            //lets find generators that fixes all points before current point
            ArrayList<Permutation> stabilizerGenerators = new ArrayList<>();
            allgenerators:
            for (Permutation stabilizerGenerator : generators) {
                for (int j = 0; j < i; ++j)
                    if (stabilizerGenerator.newIndexOf(base.get(j)) != base.get(j))
                        continue allgenerators;
                stabilizerGenerators.add(stabilizerGenerator);
            }
            BSGS.add(new BSGSCandidateElement(base.get(i), stabilizerGenerators, degree));
        }


        //make use all unused generators
        makeUseOfAllGenerators(BSGS);

View Full Code Here

                Permutation transversal = BSGS.get(i).getTransversalOf(nextBasePoint);
                int newIndexUnderInverse = transversal.newIndexOfUnderInverse(jthBeta);
                //check whether beta_{i+1}^(inverse transversal) belongs to orbit of G^{i+1}
                if (!BSGS.get(i + 1).belongsToOrbit(newIndexUnderInverse)) {
                    //then this transversal is bad and we can skip the orbit of this point under new stabilizers
                    IntArrayList toRemove = Permutations.getOrbitList(
                            newOrbitStabilizer.stabilizerGenerators, nextBasePoint, effectiveDegree);
                    allowedPoints.setAll(toRemove, false);
                } else {
                    //<-ok this transversal is good
                    //we need an element in G^(4) that beta_{i+1}^element = beta_{i+1}^{inverse transversal}
                    //so that beta_{i+1} is fixed under product of element * transversal
                    //todo unnecessary composition can be carried out!
                    Permutation newStabilizer =
                            BSGS.get(i + 1).getTransversalOf(newIndexUnderInverse).composition(transversal);
                    //if this element was not yet seen
                    if (!newOrbitStabilizer.belongsToOrbit(newStabilizer.newIndexOf(ithBeta))) {
                        newOrbitStabilizer.addStabilizer(newStabilizer);
                        IntArrayList toRemove = Permutations.getOrbitList(
                                newOrbitStabilizer.stabilizerGenerators, nextBasePoint, effectiveDegree);
                        allowedPoints.setAll(toRemove, false);
                        continue main;
                    }
                }

View Full Code Here

                stabilizers.add(p.moveRight(degree1));


            int[] SchreierVector = new int[deg];
            Arrays.fill(SchreierVector, 0, degree1, -2);
            System.arraycopy(element.SchreierVector.data, 0, SchreierVector, degree1, degree2);
            IntArrayList orbit = new IntArrayList(element.orbitList.size());
            for (int i = element.orbitList.size() - 1; i >= 0; --i)
                orbit.add(element.orbitList.get(i) + degree1);
            groupBsgsExtended.add(new BSGSElement(element.basePoint + degree1, stabilizers,
                    new SchreierVector(SchreierVector), orbit));
        }


        ArrayList<BSGSElement> bsgs = new ArrayList<>(bsgs1.size() + bsgs2.size());

View Full Code Here

        // if degree is even: p1 = (012) and (1,2,...,degree) (in cycle notation)


        ArrayList<BSGSElement> bsgs = new ArrayList<>();
        ArrayList<Permutation> stabilizers = new ArrayList<>(degree);
        for (int i = 0; i < degree - 2; ++i) {
            IntArrayList orbit = new IntArrayList(degree - i);
            for (int j = i; j < degree; ++j)
                orbit.add(j);


            int[] SchreierVector = new int[degree];
            Arrays.fill(SchreierVector, -2);
            SchreierVector[i] = -1;

View Full Code Here


        ArrayList<BSGSElement> bsgs = new ArrayList<>(degree - 1);
        for (int i = 0; i < degree - 1; ++i) {


            //calculating orbit of i-th base point
            IntArrayList orbit = new IntArrayList(degree - i);
            int j = i;
            for (; j < degree; ++j)
                orbit.add(j);


            //calculating stabilizers
            final Permutation[] stabilizers = new Permutation[degree - i - 1];

View Full Code Here


        ArrayList<BSGSElement> bsgs = new ArrayList<>(degree - 1);
        for (int i = 0; i < degree - 1; ++i) {


            //calculating orbit of i-th base point
            IntArrayList orbit = new IntArrayList(degree - i);
            int j = i;
            for (; j < degree; ++j)
                orbit.add(j);


            //calculating stabilizers
            final ArrayList<Permutation> stabilizers = new ArrayList<>((int) (FastMath.log(degree - i) / FastMath.log(2)));


            //first stabilizer is transposition

View Full Code Here

    public static Tensor[] allStatesCombinations(Tensor st) {


        Indices indices = st.getIndices().getFree();
        int[] indicesArray = indices.getAllIndices().copy();
        //lowering all indices
        IntArrayList metricIndices = new IntArrayList(),
                nonMetricIndices = new IntArrayList();


        for (int i = 0; i < indices.size(); ++i) {
            if (CC.isMetric(getType(indices.get(i))))
                metricIndices.add(getNameWithType(indices.get(i)));
            else
                nonMetricIndices.add(indices.get(i));
        }




        final int[] metricInds = metricIndices.toArray();
        ArrayList<Tensor> samples = new ArrayList<>(ArithmeticUtils.pow(2, metricInds.length));
        IntCombinationsGenerator gen;
        int[] temp;
        ArrayList<Tensor> combinationArray;
        for (int i = 0; i <= metricInds.length; ++i) {
            gen = new IntCombinationsGenerator(metricInds.length, i);
            combinationArray = new ArrayList<>();
            combinations:
            for (int[] combination : gen) {
                temp = new int[metricInds.length];
                Arrays.fill(temp, 0xFFFFFFFF);
                for (int j = combination.length - 1; j >= 0; --j)
                    temp[combination[j]] = createIndex(j, getType(metricInds[combination[j]]), true);//raise index
                int counter = combination.length;
                for (int j = 0; j < metricInds.length; ++j)
                    if (temp[j] == 0xFFFFFFFF)
                        temp[j] = createIndex(counter++, getType(metricInds[j]), false);//lower index
                IntArrayList _result = nonMetricIndices.clone();
                _result.addAll(temp);
                Tensor renamed = ApplyIndexMapping.applyIndexMapping(st, new Mapping(indicesArray, _result.toArray()));
                //todo bottleneck
                for (Tensor existing : combinationArray)
                    if (TensorUtils.compare1(existing, renamed) != null)
                        continue combinations;
                combinationArray.add(renamed);

View Full Code Here

        throw new IndexOutOfBoundsException();
    }


    @Override
    public Indices getFree() {
        IntArrayList list = new IntArrayList();
        int u, l;
        int iLower = firstLower, iUpper = 0;
        for (; iUpper < firstLower && iLower < data.length; ++iLower, ++iUpper) {
            u = data[iUpper] & 0x7FFFFFFF; //taking name with type
            l = data[iLower];
            if (u < l) {
                list.add(data[iUpper]);
                --iLower;
            } else if (l < u) {
                list.add(l);
                --iUpper;
            }
        }
        list.add(data, iUpper, firstLower - iUpper);
        list.add(data, iLower, data.length - iLower);
        return IndicesFactory.create(list.toArray());
    }

View Full Code Here

        return IndicesFactory.create(list.toArray());
    }


    @Override
    public int[] getNamesOfDummies() {
        IntArrayList list = new IntArrayList();
        int u, l;
        int iLower = firstLower, iUpper = 0;
        for (; iUpper < firstLower && iLower < data.length; ++iLower, ++iUpper) {
            u = data[iUpper] & 0x7FFFFFFF; //taking name with type
            l = data[iLower];
            if (u < l)
                --iLower;
            else if (l < u)
                --iUpper;
            else
                list.add(l);
        }
        return list.toArray();
    }

View Full Code Here

        Tensor c;
        while ((c = iterator.next()) != null) {
            if (!(c instanceof Sum))
                continue;
            Tensor remainder = c, temp;
            IntArrayList symbolicPositions = new IntArrayList();
            for (int i = c.size() - 1; i >= 0; --i) {
                temp = c.get(i);
                if (isSymbolic(temp)) {
                    symbolicPositions.add(i);
                    if (remainder instanceof Sum)
                        remainder = ((Sum) remainder).remove(i);
                    else remainder = Complex.ZERO;
                }
            }
            Tensor symbolicPart = ((Sum) c).select(symbolicPositions.toArray());
            symbolicPart = factorSymbolicTerm(symbolicPart);
            if (remainder instanceof Sum) {
                SumBuilder sb = new SumBuilder(remainder.size());
                for (Tensor tt : remainder)
                    sb.put(factorSymbolicTerms(tt));

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of cc.redberry.core.utils.IntArrayList

cc.redberry.core.context.NameDescriptorForTensorFieldDerivative

cc.redberry.core.graph.PrimitiveSubgraphPartition

cc.redberry.core.groups.permutations.AlgorithmsBase

cc.redberry.core.groups.permutations.BSGSCandidateElement

cc.redberry.core.groups.permutations.PermutationOneLineAbstract

cc.redberry.core.groups.permutations.Permutations

cc.redberry.core.groups.permutations.SchreierSimsAlgorithm

cc.redberry.core.groups.permutations.SGSIntermediateElement

cc.redberry.core.indexmapping.ProviderSimpleTensor

cc.redberry.core.indices.AbstractIndices

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.