/** * Méthode appelée pour le calcul de la cohésion entre 2 fonctions. * * <p>Calcule le pourcentage de types utilisés en commun dans les deux fonctions sur le nombre * total de types utilisés dans les deux fonctions. * * @param f1 Une fonction d'un modèle de code source * @param f2 Une autre fonction d'un modèle de code source * @return Un double entre 0.0 et 100.0 * @see #cohesion(Function, Function) */ private double cohesionTypes(Function f1, Function f2) { double result = 0.0; Map<ComplexType, Integer> usedTypesFct1 = f1.getTotalComplexTypes(); Map<ComplexType, Integer> usedTypesFct2 = f2.getTotalComplexTypes(); Set<ComplexType> usedTypesTotal = new HashSet<ComplexType>(); Set<ComplexType> usedTypesCommon = new HashSet<ComplexType>(); for (ComplexType t : usedTypesFct1.keySet()) { if (t.equals(PrimitiveType.voidType) == false && t.equals(ComplexType.anonymousType) == false) { usedTypesTotal.add(t); } } for (ComplexType t : usedTypesFct2.keySet()) { if (t.equals(PrimitiveType.voidType) == false && t.equals(ComplexType.anonymousType) == false) { boolean newType = usedTypesTotal.add(t); if (newType == false) { usedTypesCommon.add(t); } } } if (usedTypesTotal.size() > 0) { result = (100.0 * usedTypesCommon.size()) / usedTypesTotal.size(); } return result; }
/** * Évalue la cohésion entre une fonction et un type. * * <p>La cohésion entre une fonction <em>f</em> et un type <em>t</em> est égal au pourcentage * d'utilisations de <em>t</em> par <em>f</em> sur le nombre total d'utilisations de l'ensemble * des types utilisés par <em>f</em>. * * @param fct Une fonction d'un modèle de code source * @param type Un type d'un modèle de code source * @return Un double entre 0.0 et 100.0 */ private double cohesion(final Function fct, ComplexType type) { double result = 0.0; double nbUsesOfType = 0.0; double total = 0.0; // Total uses of types Map<ComplexType, Integer> usedTypes = fct.getTotalComplexTypes(); for (ComplexType t : usedTypes.keySet()) { if (t.equals(type)) { nbUsesOfType += usedTypes.get(t); } total += usedTypes.get(t); } // Same file ? if (fct.getSourceFile() != null && type.getSourceFile() != null) { if (fct.getSourceFile().equals(type.getSourceFile())) { nbUsesOfType *= BONUS_SAME_FILE; } } if (total > 0) { result = 100.0 * nbUsesOfType / total; } return result; }