forester/java/src/org/forester/pccx/TestPccx.java

   1 // $Id:
   2 // FORESTER -- software libraries and applications
   3 // for evolutionary biology research and applications.
   4 //
   5 // Copyright (C) 2008-2009 Christian M. Zmasek
   6 // Copyright (C) 2008-2009 Burnham Institute for Medical Research
   7 // All rights reserved
   8 //
   9 // This library is free software; you can redistribute it and/or
  10 // modify it under the terms of the GNU Lesser General Public
  11 // License as published by the Free Software Foundation; either
  12 // version 2.1 of the License, or (at your option) any later version.
  13 //
  14 // This library is distributed in the hope that it will be useful,
  15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17 // Lesser General Public License for more details.
  18 //
  19 // You should have received a copy of the GNU Lesser General Public
  20 // License along with this library; if not, write to the Free Software
  21 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  22 //
  23 // Contact: phylosoft @ gmail . com
  24 // WWW: https://sites.google.com/site/cmzmasek/home/software/forester
  25
  26 package org.forester.pccx;
  27
  28 import java.util.ArrayList;
  29 import java.util.List;
  30
  31 import org.forester.io.parsers.nhx.NHXParser;
  32 import org.forester.phylogeny.Phylogeny;
  33 import org.forester.phylogeny.factories.ParserBasedPhylogenyFactory;
  34 import org.forester.phylogeny.factories.PhylogenyFactory;
  35
  36 /*
  37  * @author Christian M. Zmasek
  38  */
  39 public class TestPccx {
  40
  41     private final static double ZERO_DIFF = 1.0E-6;
  42
  43     private static boolean isEqual( final double a, final double b ) {
  44         return ( ( Math.abs( a - b ) ) < TestPccx.ZERO_DIFF );
  45     }
  46
  47     public static boolean test() {
  48         if ( !TestPccx.testExternalNodeBasedCoverage() ) {
  49             return false;
  50         }
  51         return true;
  52     }
  53
  54     private static boolean testExternalNodeBasedCoverage() {
  55         try {
  56             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
  57             final String ps1 = "((((A:0.1,B:0.7):0.2,C:1.0):2.0,D:1.7):1.3,((E:0.3,F:0.4):1.1,(G:0.5,H:0.6):1.2):1.4,X:2.0)";
  58             final Phylogeny p1 = factory.create( ps1, new NHXParser() )[ 0 ];
  59             final List<Phylogeny> phylogenies = new ArrayList<Phylogeny>();
  60             final List<String> names = new ArrayList<String>();
  61             phylogenies.add( p1 );
  62             names.add( "A" );
  63             names.add( "A" );
  64             final CoverageCalculationOptions options = new ExternalNodeBasedCoverageMethodOptions( "org.forester.pccx.BranchCountingBasedScoringMethod" );
  65             final CoverageCalculator cc = CoverageCalculator.getInstance( new ExternalNodeBasedCoverageMethod(),
  66                                                                           options );
  67             Coverage cov = cc.calculateCoverage( phylogenies, names, false );
  68             if ( !TestPccx.isEqual( cov.getScore(), ( 1.0 + ( 1.0 / 2 ) + ( 1.0 / 3 ) + ( 1.0 / 4 ) + ( 1.0 / 7 )
  69                     + ( 1.0 / 7 ) + ( 1.0 / 7 ) + ( 1.0 / 7 ) + ( 1.0 / 5 ) ) / 9 ) ) {
  70                 return false;
  71             }
  72             names.add( "B" );
  73             names.add( "B" );
  74             cov = cc.calculateCoverage( phylogenies, names, false );
  75             if ( !TestPccx.isEqual( cov.getScore(), ( 1.0 + 1.0 + ( 1.0 / 3 ) + ( 1.0 / 4 ) + ( 1.0 / 7 ) + ( 1.0 / 7 )
  76                     + ( 1.0 / 7 ) + ( 1.0 / 7 ) + ( 1.0 / 5 ) ) / 9 ) ) {
  77                 return false;
  78             }
  79             names.add( "G" );
  80             cov = cc.calculateCoverage( phylogenies, names, false );
  81             if ( !TestPccx.isEqual( cov.getScore(), ( 1.0 + 1.0 + ( 1.0 / 3 ) + ( 1.0 / 4 ) + ( 1.0 / 4 ) + ( 1.0 / 4 )
  82                     + 1.0 + ( 1.0 / 2 ) + ( 1.0 / 4 ) ) / 9 ) ) {
  83                 return false;
  84             }
  85             names.add( "E" );
  86             cov = cc.calculateCoverage( phylogenies, names, false );
  87             if ( !TestPccx.isEqual( cov.getScore(), ( 1.0 + 1.0 + ( 1.0 / 3 ) + ( 1.0 / 4 ) + 1.0 + ( 1.0 / 2 ) + 1.0
  88                     + ( 1.0 / 2 ) + ( 1.0 / 4 ) ) / 9 ) ) {
  89                 return false;
  90             }
  91             names.add( "X" );
  92             cov = cc.calculateCoverage( phylogenies, names, false );
  93             if ( !TestPccx.isEqual( cov.getScore(), ( 1.0 + 1.0 + ( 1.0 / 3 ) + ( 1.0 / 3 ) + 1.0 + ( 1.0 / 2 ) + 1.0
  94                     + ( 1.0 / 2 ) + 1.0 ) / 9 ) ) {
  95                 return false;
  96             }
  97             names.add( "C" );
  98             names.add( "C" );
  99             names.add( "C" );
 100             cov = cc.calculateCoverage( phylogenies, names, false );
 101             if ( !TestPccx.isEqual( cov.getScore(), ( 1.0 + 1.0 + 1.0 + ( 1.0 / 3 ) + 1.0 + ( 1.0 / 2 ) + 1.0
 102                     + ( 1.0 / 2 ) + 1.0 ) / 9 ) ) {
 103                 return false;
 104             }
 105             names.add( "D" );
 106             cov = cc.calculateCoverage( phylogenies, names, false );
 107             if ( !TestPccx.isEqual( cov.getScore(),
 108                                     ( 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + ( 1.0 / 2 ) + 1.0 + ( 1.0 / 2 ) + 1.0 ) / 9 ) ) {
 109                 return false;
 110             }
 111             names.add( "F" );
 112             cov = cc.calculateCoverage( phylogenies, names, false );
 113             if ( !TestPccx
 114                     .isEqual( cov.getScore(), ( 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + ( 1.0 / 2 ) + 1.0 ) / 9 ) ) {
 115                 return false;
 116             }
 117             names.add( "H" );
 118             cov = cc.calculateCoverage( phylogenies, names, false );
 119             if ( !TestPccx.isEqual( cov.getScore(), ( 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + 1.0 ) / 9 ) ) {
 120                 return false;
 121             }
 122             final CoverageExtender ce = new BasicExternalNodeBasedCoverageExtender();
 123             List<String> l = ce
 124                     .find( phylogenies,
 125                            null,
 126                            0,
 127                            new ExternalNodeBasedCoverageMethodOptions( "org.forester.pccx.BranchCountingBasedScoringMethod" ),
 128                            null );
 129             if ( !l.get( 0 ).equals( "X" ) ) {
 130                 return false;
 131             }
 132             if ( !l.get( 1 ).equals( "A" ) ) {
 133                 return false;
 134             }
 135             if ( !l.get( 2 ).equals( "E" ) ) {
 136                 return false;
 137             }
 138             if ( !l.get( 3 ).equals( "G" ) ) {
 139                 return false;
 140             }
 141             if ( !l.get( 4 ).equals( "C" ) ) {
 142                 return false;
 143             }
 144             if ( !l.get( 5 ).equals( "D" ) ) {
 145                 return false;
 146             }
 147             if ( !l.get( 6 ).equals( "B" ) ) {
 148                 return false;
 149             }
 150             if ( !l.get( 7 ).equals( "F" ) ) {
 151                 return false;
 152             }
 153             if ( !l.get( 8 ).equals( "H" ) ) {
 154                 return false;
 155             }
 156             final List<String> already_covered = new ArrayList<String>();
 157             already_covered.add( "A" );
 158             already_covered.add( "X" );
 159             already_covered.add( "H" );
 160             already_covered.add( "C" );
 161             l = ce.find( phylogenies,
 162                          already_covered,
 163                          0,
 164                          new ExternalNodeBasedCoverageMethodOptions( "org.forester.pccx.BranchCountingBasedScoringMethod" ),
 165                          null );
 166             if ( !l.get( 0 ).equals( "E" ) ) {
 167                 return false;
 168             }
 169             if ( !l.get( 1 ).equals( "D" ) ) {
 170                 return false;
 171             }
 172             if ( !l.get( 2 ).equals( "B" ) ) {
 173                 return false;
 174             }
 175             if ( !l.get( 3 ).equals( "F" ) ) {
 176                 return false;
 177             }
 178             if ( !l.get( 4 ).equals( "G" ) ) {
 179                 return false;
 180             }
 181             final String ps2 = "((((A:0.1,B:0.7):0.2,C:1.0):2.0,D:1.7):1.3,((E:0.3,F:0.4):1.1,(G:0.5,H:0.6):1.2):1.4,X:2.0)";
 182             final String ps3 = "((((A:0.1,B:0.1):0.2,C:1.0):2.0,D:1.7):1.3,((E:0.3,F:0.4):1.1,(G:0.5,H:0.6):1.2):1.4,X:2.0)";
 183             final String ps4 = "((((A:0.1,B:0.05):0.2,C:1.0):2.0,D:1.7):1.3,((E:0.3,F:0.4):1.1,(G:0.5,H:0.6):1.2):1.4,X:2.0)";
 184             final Phylogeny p2 = factory.create( ps2, new NHXParser() )[ 0 ];
 185             final Phylogeny p3 = factory.create( ps3, new NHXParser() )[ 0 ];
 186             final Phylogeny p4 = factory.create( ps4, new NHXParser() )[ 0 ];
 187             final List<Phylogeny> phylogenies2 = new ArrayList<Phylogeny>();
 188             final List<String> names2 = new ArrayList<String>();
 189             phylogenies2.add( p2 );
 190             phylogenies2.add( p3 );
 191             phylogenies2.add( p4 );
 192             names2.add( "A" );
 193             names2.add( "A" );
 194             final CoverageCalculationOptions options2 = new ExternalNodeBasedCoverageMethodOptions( "org.forester.pccx.BranchLengthBasedScoringMethod" );
 195             final CoverageCalculator cc2 = CoverageCalculator.getInstance( new ExternalNodeBasedCoverageMethod(),
 196                                                                            options2 );
 197             Coverage cov2 = cc2.calculateCoverage( phylogenies2, names2, false );
 198             final double nf = 1 / ( ( 1 / 0.1 ) + ( 1 / 0.7 ) + ( 1 / 1.0 ) + ( 1 / 1.7 ) + ( 1 / 0.3 ) + ( 1 / 0.4 )
 199                     + ( 1 / 0.5 ) + ( 1 / 0.6 ) + ( 1 / 2.0 ) );
 200             if ( !TestPccx.isEqual( cov2.getScore(), ( ( 1 / 0.1 )
 201                     + ( ( ( 1 / 0.8 ) + ( 1 / 0.2 ) + ( 1 / 0.15 ) ) / 3 ) + ( 1 / 1.3 ) + ( 1 / 4.0 ) + ( 1 / 6.4 )
 202                     + ( 1 / 6.5 ) + ( 1 / 6.7 ) + ( 1 / 6.8 ) + ( 1 / 5.6 ) )
 203                     * nf ) ) {
 204                 return false;
 205             }
 206             names2.add( "C" );
 207             cov2 = cc2.calculateCoverage( phylogenies2, names2, false );
 208             if ( !TestPccx.isEqual( cov2.getScore(), ( ( 1 / 0.1 )
 209                     + ( ( ( 1 / 0.8 ) + ( 1 / 0.2 ) + ( 1 / 0.15 ) ) / 3 ) + ( 1 / 1.0 ) + ( 1 / 4.0 ) + ( 1 / 6.4 )
 210                     + ( 1 / 6.5 ) + ( 1 / 6.7 ) + ( 1 / 6.8 ) + ( 1 / 5.6 ) )
 211                     * nf ) ) {
 212                 return false;
 213             }
 214             names2.add( "E" );
 215             cov2 = cc2.calculateCoverage( phylogenies2, names2, false );
 216             if ( !TestPccx.isEqual( cov2.getScore(), ( ( 1 / 0.1 )
 217                     + ( ( ( 1 / 0.8 ) + ( 1 / 0.2 ) + ( 1 / 0.15 ) ) / 3 ) + ( 1 / 1.0 ) + ( +1 / 4.0 ) + ( 1 / 0.3 )
 218                     + ( 1 / 0.7 ) + ( 1 / 3.1 ) + ( 1 / 3.2 ) + ( 1 / 4.8 ) )
 219                     * nf ) ) {
 220                 return false;
 221             }
 222             final CoverageCalculationOptions options_log = new ExternalNodeBasedCoverageMethodOptions( "org.forester.pccx.LogBranchLengthBasedScoringMethod" );
 223             final CoverageCalculator cclog = CoverageCalculator.getInstance( new ExternalNodeBasedCoverageMethod(),
 224                                                                              options_log );
 225             final Coverage cov_log = cclog.calculateCoverage( phylogenies2, names2, false );
 226             if ( !TestPccx.isEqual( cov_log.getScore(), 0.8534252108361485 ) ) {
 227                 return false;
 228             }
 229             final String ps10 = "((((A:0.1,B:0.7):0.2,C:1.0):2.0,D:1.7):1.3,((E:0.3,F:0.4):1.1,(G:0.5,H:0.6):1.2):1.4,((((I:0.1,J:0.7):0.2,K:1.0):2.0,L:1.7):1.3,((M:0.3,N:0.4,O:0.1,P:0.2):1.1,(Q:0.5,R:0.6):1.2):1.4,S:2.0):2.0)";
 230             final Phylogeny p10 = factory.create( ps10, new NHXParser() )[ 0 ];
 231             final List<Phylogeny> phylogenies10 = new ArrayList<Phylogeny>();
 232             final List<String> names10 = new ArrayList<String>();
 233             phylogenies10.add( p10 );
 234             names10.add( "A" );
 235             names10.add( "B" );
 236             names10.add( "N" );
 237             names10.add( "O" );
 238             final CoverageCalculationOptions options10 = new ExternalNodeBasedCoverageMethodOptions( "org.forester.pccx.BranchCountingBasedScoringMethod" );
 239             final CoverageCalculator cc10 = CoverageCalculator.getInstance( new ExternalNodeBasedCoverageMethod(),
 240                                                                             options10 );
 241             cc10.calculateCoverage( phylogenies10, names10, true );
 242         }
 243         catch ( final Exception e ) {
 244             e.printStackTrace( System.out );
 245             return false;
 246         }
 247         return true;
 248     }
 249 }