version 0.9910 beta

[jalview.git] / forester / java / src / org / forester / surfacing / BasicDomainSimilarityCalculator.java

diff --git a/forester/java/src/org/forester/surfacing/BasicDomainSimilarityCalculator.java b/forester/java/src/org/forester/surfacing/BasicDomainSimilarityCalculator.java
index 81cef33..8682fd1 100644 (file)
--- a/forester/java/src/org/forester/surfacing/BasicDomainSimilarityCalculator.java
+++ b/forester/java/src/org/forester/surfacing/BasicDomainSimilarityCalculator.java
@@ -43,22 +43,32 @@ import org.forester.util.ForesterUtil;
 public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculator {
 
     final DomainSimilarity.DomainSimilaritySortField _sort;
+    private final boolean                            _calc_similarity_score;
     private final boolean                            _sort_by_species_count_first;
     private final boolean                            _treat_as_binary_comparison;
-    private final boolean                            _calc_similarity_score;
+    private final boolean                            _verbose;
 
     public BasicDomainSimilarityCalculator( final DomainSimilarity.DomainSimilaritySortField sort,
                                             final boolean sort_by_species_count_first,
                                             final boolean treat_as_binary_comparison,
-                                            final boolean calc_similarity_score ) {
+                                            final boolean calc_similarity_score,
+                                            final boolean verbose ) {
         _sort = sort;
         _sort_by_species_count_first = sort_by_species_count_first;
         _treat_as_binary_comparison = treat_as_binary_comparison;
         _calc_similarity_score = calc_similarity_score;
+        _verbose = verbose;
     }
 
-    public boolean isCalcSimilarityScore() {
-        return _calc_similarity_score;
+    public BasicDomainSimilarityCalculator( final DomainSimilarity.DomainSimilaritySortField sort,
+                                            final boolean sort_by_species_count_first,
+                                            final boolean treat_as_binary_comparison,
+                                            final boolean calc_similarity_score ) {
+        _sort = sort;
+        _sort_by_species_count_first = sort_by_species_count_first;
+        _treat_as_binary_comparison = treat_as_binary_comparison;
+        _calc_similarity_score = calc_similarity_score;
+        _verbose = false;
     }
 
     @Override
@@ -76,9 +86,13 @@ public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculat
         }
         final DecimalFormat pf = new java.text.DecimalFormat( "000000" );
         int counter = 1;
-        System.out.println( keys.size() );
+        if ( _verbose ) {
+            System.out.println( keys.size() );
+        }
         for( final String key : keys ) {
-            ForesterUtil.updateProgress( counter, pf );
+            if ( _verbose ) {
+                ForesterUtil.updateProgress( counter, pf );
+            }
             counter++;
             final List<CombinableDomains> same_id_cd_list = new ArrayList<CombinableDomains>( cdc_list.size() );
             final List<Species> species_with_key_id_domain = new ArrayList<Species>();
@@ -115,10 +129,16 @@ public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculat
                 throw new RuntimeException( "this should not have happened" );
             }
         }
-        System.out.println();
+        if ( _verbose ) {
+            System.out.println();
+        }
         return similarities;
     }
 
+    public boolean isCalcSimilarityScore() {
+        return _calc_similarity_score;
+    }
+
     private DomainSimilarity calculateSimilarity( final PairwiseDomainSimilarityCalculator pairwise_calculator,
                                                   final List<CombinableDomains> domains_list ) {
         if ( domains_list.size() == 1 ) {
@@ -126,26 +146,26 @@ public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculat
             species_data.put( domains_list.get( 0 ).getSpecies(),
                               createSpeciesSpecificDomainSimilariyData( domains_list.get( 0 ) ) );
             if ( !isCalcSimilarityScore() ) {
-                return new PrintableDomainSimilarity( domains_list.get( 0 ),
-                                                      0,
-                                                      0,
-                                                      species_data,
-                                                      isSortBySpeciesCountFirst(),
-                                                      isTreatAsBinaryComparison() );
+                return new DomainSimilarity( domains_list.get( 0 ),
+                                             0,
+                                             0,
+                                             species_data,
+                                             isSortBySpeciesCountFirst(),
+                                             isTreatAsBinaryComparison() );
             }
             else {
-                return new PrintableDomainSimilarity( domains_list.get( 0 ),
-                                                      1.0,
-                                                      1.0,
-                                                      1.0,
-                                                      1.0,
-                                                      0.0,
-                                                      0,
-                                                      0,
-                                                      0,
-                                                      species_data,
-                                                      isSortBySpeciesCountFirst(),
-                                                      isTreatAsBinaryComparison() );
+                return new DomainSimilarity( domains_list.get( 0 ),
+                                             1.0,
+                                             1.0,
+                                             1.0,
+                                             1.0,
+                                             0.0,
+                                             0,
+                                             0,
+                                             0,
+                                             species_data,
+                                             isSortBySpeciesCountFirst(),
+                                             isTreatAsBinaryComparison() );
             }
         }
         DescriptiveStatistics stat = null;
@@ -201,41 +221,41 @@ public class BasicDomainSimilarityCalculator implements DomainSimilarityCalculat
         }
         DomainSimilarity similarity = null;
         if ( !isCalcSimilarityScore() ) {
-            similarity = new PrintableDomainSimilarity( domains_list.get( 0 ),
-                                                        max_difference_in_counts,
-                                                        max_difference,
-                                                        species_data,
-                                                        isSortBySpeciesCountFirst(),
-                                                        isTreatAsBinaryComparison() );
+            similarity = new DomainSimilarity( domains_list.get( 0 ),
+                                               max_difference_in_counts,
+                                               max_difference,
+                                               species_data,
+                                               isSortBySpeciesCountFirst(),
+                                               isTreatAsBinaryComparison() );
         }
         else {
             if ( stat.getN() == 1 ) {
-                similarity = new PrintableDomainSimilarity( domains_list.get( 0 ),
-                                                            stat.getMin(),
-                                                            stat.getMax(),
-                                                            stat.arithmeticMean(),
-                                                            stat.median(),
-                                                            0.0,
-                                                            stat.getN(),
-                                                            max_difference_in_counts,
-                                                            max_difference,
-                                                            species_data,
-                                                            isSortBySpeciesCountFirst(),
-                                                            isTreatAsBinaryComparison() );
+                similarity = new DomainSimilarity( domains_list.get( 0 ),
+                                                   stat.getMin(),
+                                                   stat.getMax(),
+                                                   stat.arithmeticMean(),
+                                                   stat.median(),
+                                                   0.0,
+                                                   stat.getN(),
+                                                   max_difference_in_counts,
+                                                   max_difference,
+                                                   species_data,
+                                                   isSortBySpeciesCountFirst(),
+                                                   isTreatAsBinaryComparison() );
             }
             else {
-                similarity = new PrintableDomainSimilarity( domains_list.get( 0 ),
-                                                            stat.getMin(),
-                                                            stat.getMax(),
-                                                            stat.arithmeticMean(),
-                                                            stat.median(),
-                                                            stat.sampleStandardDeviation(),
-                                                            stat.getN(),
-                                                            max_difference_in_counts,
-                                                            max_difference,
-                                                            species_data,
-                                                            isSortBySpeciesCountFirst(),
-                                                            isTreatAsBinaryComparison() );
+                similarity = new DomainSimilarity( domains_list.get( 0 ),
+                                                   stat.getMin(),
+                                                   stat.getMax(),
+                                                   stat.arithmeticMean(),
+                                                   stat.median(),
+                                                   stat.sampleStandardDeviation(),
+                                                   stat.getN(),
+                                                   max_difference_in_counts,
+                                                   max_difference,
+                                                   species_data,
+                                                   isSortBySpeciesCountFirst(),
+                                                   isTreatAsBinaryComparison() );
             }
         }
         return similarity;