@Override public Permutation pow(int exponent) { if (isIdentity) return this; Permutation base = this, result = getIdentity(); while (exponent != 0) { if (exponent % 2 == 1) result = result.composition(base); base = base.composition(base); exponent = exponent >> 1; } return result; }
@Override public Permutation conjugate(Permutation p) { return inverse().composition(p, this); }
@Override public Permutation conjugate(Permutation p) { return inverse().composition(p, this); }
@Override public Permutation conjugate(Permutation p) { return inverse().composition(p, this); }
@Override public Permutation conjugate(Permutation p) { return inverse().composition(p, this); }
private Permutation tryPair(Permutation p0, Permutation p1) { Permutation composition = p0.composition(p1); Permutation setComposition = set.ceiling(composition); if (setComposition != null && JUST_PERMUTATION_COMPARATOR.compare(setComposition, composition) == 0) if (setComposition.equals(composition)) return null; else throw new InconsistentGeneratorsException(composition + " and " + setComposition); set.add(composition); nextLayer.add(composition); return composition; }
@Override public Permutation pow(int exponent) { if (isIdentity) return this; if (exponent < 0) return inverse().pow(-exponent); Permutation base = this, result = getIdentity(); while (exponent != 0) { if (exponent % 2 == 1) result = result.composition(base); base = base.composition(base); exponent = exponent >> 1; } return result; }
@Override public Permutation pow(int exponent) { if (isIdentity) return this; if (exponent < 0) return inverse().pow(-exponent); Permutation base = this, result = getIdentity(); while (exponent != 0) { if (exponent % 2 == 1) result = result.composition(base); base = base.composition(base); exponent = exponent >> 1; } return result; }
@Override public Permutation pow(int exponent) { if (isIdentity) return this; if (exponent < 0) return inverse().pow(-exponent); Permutation base = this, result = getIdentity(); while (exponent != 0) { if (exponent % 2 == 1) result = result.composition(base); base = base.composition(base); exponent = exponent >> 1; } return result; }
@Override public Permutation commutator(Permutation p) { return inverse().composition(p.inverse(), this, p); }
@Override public Permutation commutator(Permutation p) { return inverse().composition(p.inverse(), this, p); }
@Override public Permutation commutator(Permutation p) { return inverse().composition(p.inverse(), this, p); }
@Override public Permutation commutator(Permutation p) { return inverse().composition(p.inverse(), this, p); }
@Override public Permutation next() { Permutation p = bsgs.get(0).getInverseTransversalOf(bsgs.get(0).getOrbitPoint(tuple[0])); BSGSElement e; for (int i = 1, size = bsgs.size(); i < size; ++i) { e = bsgs.get(i); p = p.composition(e.getInverseTransversalOf(e.getOrbitPoint(tuple[i]))); } tuple = tuplesPort.take(); return p; }
private void backtrack() { while (level >= 0 && tuple[level] == bsgs.get(level).orbitList.size() - 1) --level; if (level == -1) return; ++tuple[level]; if (level == 0) word[0] = bsgs.get(0).getTransversalOf(sortedOrbits[0][tuple[0]]); else word[level] = bsgs.get(level).getTransversalOf( word[level - 1].newIndexOfUnderInverse(sortedOrbits[level][tuple[level]]) ).composition(word[level - 1]); }
@Override public void beforeLevelIncrement(int level) { int image = wordReference[level].newIndexOf(base[level]); if (level == 0) intersectionWord[level] = larger.get(level).getTransversalOf(image); else intersectionWord[level] = larger.get(level).getTransversalOf(intersectionWord[level - 1] .newIndexOfUnderInverse(image)).composition(intersectionWord[level - 1]); }
/** * Returns uniformly distributed random permutation from this group. * * @param generator random generator to be used in generation of random permutation * @return uniformly distributed random permutation from this group */ public Permutation randomElement(RandomGenerator generator) { // Getting BSGS List<BSGSElement> bsgs = getBSGS(); // Getting random transversal from first BSGS element BSGSElement element = bsgs.get(0); Permutation result = element.getTransversalOf(element.getOrbitPoint(generator.nextInt(element.orbitSize()))); for (int i = 1; i < bsgs.size(); ++i) { element = bsgs.get(i); // Multiplying result by random transversal from each BSGS element result = result.composition(element.getTransversalOf(element.getOrbitPoint(generator.nextInt(element.orbitSize())))); } return result; }
/** * Searches and returns the next element in group. * * @return next element in group */ @Override public Permutation take() { if (level == -1) return null; while (true) { backtrack(); if (level == -1) return null; while (level < size - 1 && testFunction.test(word[level], level)) { ++level; calculateSortedOrbit(level); tuple[level] = 0; word[level] = bsgs.get(level).getTransversalOf( word[level - 1].newIndexOfUnderInverse(sortedOrbits[level][tuple[level]]) ).composition(word[level - 1]); } if (level != size - 1 || !testFunction.test(word[level], level) || !property.is(word[level])) continue; return word[level]; } }
@Override public Permutation composition(final Permutation other) { if (this.isIdentity) return other; if (other.isIdentity()) return this; final int newLength = Math.max(degree(), other.degree()); if (newLength > Byte.MAX_VALUE) return toLargerRepresentation(newLength).composition(other); byte newInternalDegree = -1; final byte[] result = new byte[newLength]; boolean resultIsIdentity = true; for (byte i = 0; i < newLength; ++i) { result[i] = (byte) other.newIndexOf(newIndexOf(i)); resultIsIdentity &= result[i] == i; newInternalDegree = result[i] == i ? newInternalDegree : i; } try { return new PermutationOneLineByte(resultIsIdentity, antisymmetry ^ other.antisymmetry(), (byte) (newInternalDegree + 1), result); } catch (InconsistentGeneratorsException ex) { throw new InconsistentGeneratorsException(this + " and " + other); } }
@Override public Permutation composition(Permutation a, Permutation b) { if (this.isIdentity) return a.composition(b); if (a.isIdentity()) return composition(b); if (b.isIdentity()) return composition(a); final int newLength = Math.max(Math.max(degree(), a.degree()), b.degree()); int newInternalDegree = -1; final int[] result = new int[newLength]; boolean resultIsIdentity = true; for (int i = 0; i < newLength; ++i) { result[i] = b.newIndexOf(a.newIndexOf(newIndexOf(i))); resultIsIdentity &= result[i] == i; newInternalDegree = result[i] == i ? newInternalDegree : i; } try { return new PermutationOneLineInt(resultIsIdentity, antisymmetry ^ a.antisymmetry() ^ b.antisymmetry(), newInternalDegree + 1, result); } catch (InconsistentGeneratorsException ex) { throw new InconsistentGeneratorsException(this + " and " + a + " and " + b); } }