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