forester/java/src/org/forester/evoinference/distance/S.java

   1
   2 package org.forester.evoinference.distance;
   3
   4 import java.text.DecimalFormat;
   5 import java.util.ArrayList;
   6 import java.util.List;
   7 import java.util.Map.Entry;
   8 import java.util.Set;
   9 import java.util.SortedMap;
  10 import java.util.SortedSet;
  11 import java.util.TreeMap;
  12 import java.util.TreeSet;
  13
  14 import org.forester.evoinference.matrix.distance.BasicSymmetricalDistanceMatrix;
  15
  16 public final class S {
  17
  18     private final static boolean                              DEBUG = true;
  19     private final List<SortedMap<Double, SortedSet<Integer>>> _data;
  20
  21     public S() {
  22         _data = new ArrayList<SortedMap<Double, SortedSet<Integer>>>();
  23     }
  24
  25     final public void addPairing( final double key, final int value, final int j ) {
  26         addPairing( key, value, getS( j ) );
  27     }
  28
  29     final public SortedMap<Double, SortedSet<Integer>> getS( final int j ) {
  30         return _data.get( j );
  31     }
  32
  33     final public SortedSet<Integer> getValues( final double key, final int j ) {
  34         return getS( j ).get( key );
  35     }
  36
  37     final public void initialize( final BasicSymmetricalDistanceMatrix d ) {
  38         for( int j = 0; j < d.getSize(); ++j ) {
  39             final TreeMap<Double, SortedSet<Integer>> map = new TreeMap<Double, SortedSet<Integer>>();
  40             _data.add( map );
  41             for( int i = 0; i < j; ++i ) {
  42                 addPairing( d.getValues()[ i ][ j ], i, map );
  43             }
  44         }
  45         System.out.println( toString() );
  46     }
  47
  48     final public void initialize( final int size ) {
  49         for( int j = 0; j < size; ++j ) {
  50             final TreeMap<Double, SortedSet<Integer>> map = new TreeMap<Double, SortedSet<Integer>>();
  51             _data.add( map );
  52         }
  53     }
  54
  55     final public void removePairing( final double key, final int value, final int j ) {
  56         final SortedMap<Double, SortedSet<Integer>> m = _data.get( j );
  57         final SortedSet<Integer> x = m.get( key );
  58         if ( x.size() == 1 ) {
  59             if ( DEBUG ) {
  60                 if ( !x.contains( value ) ) {
  61                     throw new IllegalArgumentException( "pairing " + key + " -> " + value + " does not exist for row "
  62                             + j );
  63                 }
  64             }
  65             m.remove( key );
  66         }
  67         else if ( x.size() > 1 ) {
  68             if ( DEBUG ) {
  69                 if ( !x.remove( value ) ) {
  70                     throw new IllegalArgumentException( "pairing " + key + " -> " + value
  71                             + " does not exist (could not be removed) for row " + j );
  72                 }
  73             }
  74             else {
  75                 x.remove( value );
  76             }
  77         }
  78         else if ( DEBUG ) {
  79             throw new IllegalStateException();
  80         }
  81     }
  82
  83     final public int size() {
  84         return _data.size();
  85     }
  86
  87     // Slow, only for testing
  88     @SuppressWarnings( "unchecked")
  89     final public SortedSet<Integer>[] toArray( final int j ) {
  90         return _data.get( j ).values().toArray( new SortedSet[ _data.get( j ).size() ] );
  91     }
  92
  93     @Override
  94     final public String toString() {
  95         final DecimalFormat df = new DecimalFormat( "0.00" );
  96         final StringBuilder sb = new StringBuilder();
  97         for( int j = 0; j < size(); ++j ) {
  98             for( final Entry<Double, SortedSet<Integer>> entry : getSentrySet( j ) ) {
  99                 final double key = entry.getKey();
 100                 final SortedSet<Integer> values = entry.getValue();
 101                 sb.append( df.format( key ) + "->" );
 102                 boolean first = true;
 103                 for( final Integer v : values ) {
 104                     if ( !first ) {
 105                         sb.append( "," );
 106                     }
 107                     first = false;
 108                     sb.append( v );
 109                 }
 110                 sb.append( "  " );
 111             }
 112             sb.append( "\n" );
 113         }
 114         return sb.toString();
 115     }
 116
 117     final Set<Entry<Double, SortedSet<Integer>>> getSentrySet( final int j ) {
 118         return getS( j ).entrySet();
 119     }
 120
 121     final private static void addPairing( final double key,
 122                                           final int value,
 123                                           final SortedMap<Double, SortedSet<Integer>> m ) {
 124         if ( !m.containsKey( key ) ) {
 125             final TreeSet<Integer> x = new TreeSet<Integer>();
 126             x.add( value );
 127             m.put( key, x );
 128         }
 129         else {
 130             if ( DEBUG ) {
 131                 if ( m.get( key ).contains( value ) ) {
 132                     throw new IllegalArgumentException( "pairing " + key + " -> " + value + " already exists" );
 133                 }
 134             }
 135             m.get( key ).add( value );
 136         }
 137     }
 138 }