Generate a transversal of a subgroup in this group.

@param subgroup the subgroup to use for the transversal
@return a list of permutations
962621
public List<Permutation> transversal(final PermutationGroup subgroup) {
        final long m = this.order() / subgroup.order();
        final List<Permutation> results = new ArrayList<Permutation>();
        Backtracker transversalBacktracker = new Backtracker() {

            private boolean finished = false;

            @Override
            public void applyTo(Permutation p) {
                for (Permutation f : results) {
                    Permutation h = f.invert().multiply(p);
                    if (subgroup.test(h) == size) {
                        return;
                    }
                }
                results.add(p);
                if (results.size() >= m) {
                    this.finished = true;
                }
            }

            @Override
            public boolean isFinished() {
                return finished;
            }

        };
        this.apply(transversalBacktracker);
        return results;
    }
1229585
public java.util.List<ReplicationGroup> getReplicationGroups() {
        if (replicationGroups == null) {
            replicationGroups = new com.amazonaws.internal.SdkInternalList<ReplicationGroup>();
        }
        return replicationGroups;
    }
702075
def Subgroups(self):
		

		return(Groups(alias=self.alias,groups_lst=self.data['groups'],session=self.session))
899098
@Override
    public Iterator findParentGroups(IGroupMember gm) throws GroupsException {
        if (gm.isGroup()) {
            IEntityGroup group = (IEntityGroup) gm;
            return findParentGroups(group);
        } else {
            IEntity ent = (IEntity) gm;
            return findParentGroups(ent);
        }
    }
1177106
public java.util.List<TransitGatewayAttachmentPropagation> getTransitGatewayAttachmentPropagations() {
        if (transitGatewayAttachmentPropagations == null) {
            transitGatewayAttachmentPropagations = new com.amazonaws.internal.SdkInternalList<TransitGatewayAttachmentPropagation>();
        }
        return transitGatewayAttachmentPropagations;
    }
1311014
public List<AggregationDistinctSelectItem> getAggregationDistinctSelectItems() {
        List<AggregationDistinctSelectItem> result = new LinkedList<>();
        for (SelectItem each : items) {
            if (each instanceof AggregationDistinctSelectItem) {
                result.add((AggregationDistinctSelectItem) each);
            }
        }
        return result;
    }
866757
private static List<JoinNode> generateInnerJoinOrdersForTree(JoinNode subTree) {
        // Get a list of the leaf nodes(tables) to permute them
        List<JoinNode> tableNodes = subTree.generateLeafNodesJoinOrder();
        List<List<JoinNode>> joinOrders = PermutationGenerator.generatePurmutations(tableNodes);
        List<JoinNode> newTrees = new ArrayList<>();
        for (List<JoinNode> joinOrder: joinOrders) {
            newTrees.add(JoinNode.reconstructJoinTreeFromTableNodes(joinOrder, JoinType.INNER));
        }
        //Collect all the join/where conditions to reassign them later
        AbstractExpression combinedWhereExpr = subTree.getAllFilters();
        List<JoinNode> treePermutations = new ArrayList<>();
        for (JoinNode newTree : newTrees) {
            if (combinedWhereExpr != null) {
                newTree.setWhereExpression(combinedWhereExpr.clone());
            }
            // The new tree root node id must match the original one to be able to reconnect the
            // subtrees
            newTree.setId(subTree.getId());
            treePermutations.add(newTree);
        }
        return treePermutations;
    }
471468
public static String[] toSortedArray(Set<String> groups) {
        //TODO: sort in another way than just alphabetically
        String[] sortedArray = groups.toArray(new String[groups.size()]);

        Arrays.sort(sortedArray);

        return sortedArray;
    }
1012534
private Iterator<IEntityGroup> getMemberGroups() throws GroupsException {

        Set<IEntityGroup> rslt = new HashSet<>();
        for (IGroupMember child : getChildren()) {
            if (child.isGroup()) {
                rslt.add((IEntityGroup) child);
            }
        }

        return rslt.iterator();
    }
1192930
public Setting getSetting(String group) {
		final Setting setting = new Setting();
		setting.putAll(this.getMap(group));
		return setting;
	}
42784
public List<JoinNode> generateLeafNodesJoinOrder() {
        ArrayList<JoinNode> leafNodes = new ArrayList<>();
        listNodesJoinOrderRecursive(leafNodes, false);
        return leafNodes;
    }
581928
public ResultTransformer<Map<K, Group>> as(Expression<?>... expressions) {
        return new GroupByMap<K, Group>(key, expressions);
    }
694363
public static Set<String> getIssueGroups(Collection<String> issueTypes, Map<String, Set<String>> groupingSpecification) {
        Set<String> groups = new HashSet<>();
        for (String issueType : issueTypes) {
            for (Map.Entry<String, Set<String>> entry : groupingSpecification.entrySet()) {
                String groupName = entry.getKey();
                Set<String> groupTypes = entry.getValue();
                if (groupTypes.contains(issueType)) {
                    groups.add(groupName);
                }
            }
        }
        return groups;
    }
195842
@Pure
	public Iterable<PointGroup> groups() {
		return new Iterable<PointGroup>() {
			@Override
			public Iterator<PointGroup> iterator() {
				return MapComposedElement.this.groupIterator();
			}
		};
	}
1018723
def is_supergroup(self, subgroup):
        
        warnings.warn("This is not fully functional. Only trivial subsets are "
                      "tested right now. ")
        return set(subgroup.symmetry_ops).issubset(self.symmetry_ops)
153580
public List<AggregationSelectItem> getAggregationSelectItems() {
        List<AggregationSelectItem> result = new LinkedList<>();
        for (SelectItem each : items) {
            if (each instanceof AggregationSelectItem) {
                AggregationSelectItem aggregationSelectItem = (AggregationSelectItem) each;
                result.add(aggregationSelectItem);
                result.addAll(aggregationSelectItem.getDerivedAggregationSelectItems());
            }
        }
        return result;
    }
713028
public List<String> orderedGroups() {
        int groupCount = groupCount();
        List<String> groups = new ArrayList<String>(groupCount);
        for (int i = 1; i <= groupCount; i++) {
            groups.add(group(i));
        }
        return groups;
    }