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: www.phylosoft.org/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 + 1.0 / 7 + 1.0 / 7
  69                     + 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 + 1.0 / 7 + 1.0
  76                     / 7 + 1.0 / 5 ) / 9 ) ) {
  77                 return false;
  78             }
  79             names.add( "G" );
  80             cov = cc.calculateCoverage( phylogenies, names, false );
  81             if ( !TestPccx
  82                     .isEqual( cov.getScore(),
  83                               ( 1.0 + 1.0 + 1.0 / 3 + 1.0 / 4 + 1.0 / 4 + 1.0 / 4 + 1.0 + 1.0 / 2 + 1.0 / 4 ) / 9 ) ) {
  84                 return false;
  85             }
  86             names.add( "E" );
  87             cov = cc.calculateCoverage( phylogenies, names, false );
  88             if ( !TestPccx.isEqual( cov.getScore(),
  89                                     ( 1.0 + 1.0 + 1.0 / 3 + 1.0 / 4 + 1.0 + 1.0 / 2 + 1.0 + 1.0 / 2 + 1.0 / 4 ) / 9 ) ) {
  90                 return false;
  91             }
  92             names.add( "X" );
  93             cov = cc.calculateCoverage( phylogenies, names, false );
  94             if ( !TestPccx.isEqual( cov.getScore(),
  95                                     ( 1.0 + 1.0 + 1.0 / 3 + 1.0 / 3 + 1.0 + 1.0 / 2 + 1.0 + 1.0 / 2 + 1.0 ) / 9 ) ) {
  96                 return false;
  97             }
  98             names.add( "C" );
  99             names.add( "C" );
 100             names.add( "C" );
 101             cov = cc.calculateCoverage( phylogenies, names, false );
 102             if ( !TestPccx.isEqual( cov.getScore(),
 103                                     ( 1.0 + 1.0 + 1.0 + 1.0 / 3 + 1.0 + 1.0 / 2 + 1.0 + 1.0 / 2 + 1.0 ) / 9 ) ) {
 104                 return false;
 105             }
 106             names.add( "D" );
 107             cov = cc.calculateCoverage( phylogenies, names, false );
 108             if ( !TestPccx
 109                     .isEqual( cov.getScore(), ( 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + 1.0 / 2 + 1.0 + 1.0 / 2 + 1.0 ) / 9 ) ) {
 110                 return false;
 111             }
 112             names.add( "F" );
 113             cov = cc.calculateCoverage( phylogenies, names, false );
 114             if ( !TestPccx.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
 162                     .find( phylogenies,
 163                            already_covered,
 164                            0,
 165                            new ExternalNodeBasedCoverageMethodOptions( "org.forester.pccx.BranchCountingBasedScoringMethod" ),
 166                            null );
 167             if ( !l.get( 0 ).equals( "E" ) ) {
 168                 return false;
 169             }
 170             if ( !l.get( 1 ).equals( "D" ) ) {
 171                 return false;
 172             }
 173             if ( !l.get( 2 ).equals( "B" ) ) {
 174                 return false;
 175             }
 176             if ( !l.get( 3 ).equals( "F" ) ) {
 177                 return false;
 178             }
 179             if ( !l.get( 4 ).equals( "G" ) ) {
 180                 return false;
 181             }
 182             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)";
 183             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)";
 184             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)";
 185             final Phylogeny p2 = factory.create( ps2, new NHXParser() )[ 0 ];
 186             final Phylogeny p3 = factory.create( ps3, new NHXParser() )[ 0 ];
 187             final Phylogeny p4 = factory.create( ps4, new NHXParser() )[ 0 ];
 188             final List<Phylogeny> phylogenies2 = new ArrayList<Phylogeny>();
 189             final List<String> names2 = new ArrayList<String>();
 190             phylogenies2.add( p2 );
 191             phylogenies2.add( p3 );
 192             phylogenies2.add( p4 );
 193             names2.add( "A" );
 194             names2.add( "A" );
 195             final CoverageCalculationOptions options2 = new ExternalNodeBasedCoverageMethodOptions( "org.forester.pccx.BranchLengthBasedScoringMethod" );
 196             final CoverageCalculator cc2 = CoverageCalculator.getInstance( new ExternalNodeBasedCoverageMethod(),
 197                                                                            options2 );
 198             Coverage cov2 = cc2.calculateCoverage( phylogenies2, names2, false );
 199             final double nf = 1 / ( 1 / 0.1 + 1 / 0.7 + 1 / 1.0 + 1 / 1.7 + 1 / 0.3 + 1 / 0.4 + 1 / 0.5 + 1 / 0.6 + 1 / 2.0 );
 200             if ( !TestPccx.isEqual( cov2.getScore(), ( 1 / 0.1 + ( 1 / 0.8 + 1 / 0.2 + 1 / 0.15 ) / 3 + 1 / 1.3 + 1
 201                     / 4.0 + 1 / 6.4 + 1 / 6.5 + 1 / 6.7 + 1 / 6.8 + 1 / 5.6 )
 202                     * nf ) ) {
 203                 return false;
 204             }
 205             names2.add( "C" );
 206             cov2 = cc2.calculateCoverage( phylogenies2, names2, false );
 207             if ( !TestPccx.isEqual( cov2.getScore(), ( 1 / 0.1 + ( 1 / 0.8 + 1 / 0.2 + 1 / 0.15 ) / 3 + 1 / 1.0 + 1
 208                     / 4.0 + 1 / 6.4 + 1 / 6.5 + 1 / 6.7 + 1 / 6.8 + 1 / 5.6 )
 209                     * nf ) ) {
 210                 return false;
 211             }
 212             names2.add( "E" );
 213             cov2 = cc2.calculateCoverage( phylogenies2, names2, false );
 214             if ( !TestPccx.isEqual( cov2.getScore(), ( 1 / 0.1 + ( 1 / 0.8 + 1 / 0.2 + 1 / 0.15 ) / 3 + 1 / 1.0 + +1
 215                     / 4.0 + 1 / 0.3 + 1 / 0.7 + 1 / 3.1 + 1 / 3.2 + 1 / 4.8 )
 216                     * nf ) ) {
 217                 return false;
 218             }
 219             final CoverageCalculationOptions options_log = new ExternalNodeBasedCoverageMethodOptions( "org.forester.pccx.LogBranchLengthBasedScoringMethod" );
 220             final CoverageCalculator cclog = CoverageCalculator.getInstance( new ExternalNodeBasedCoverageMethod(),
 221                                                                              options_log );
 222             final Coverage cov_log = cclog.calculateCoverage( phylogenies2, names2, false );
 223             if ( !TestPccx.isEqual( cov_log.getScore(), 0.8534252108361485 ) ) {
 224                 return false;
 225             }
 226             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)";
 227             final Phylogeny p10 = factory.create( ps10, new NHXParser() )[ 0 ];
 228             final List<Phylogeny> phylogenies10 = new ArrayList<Phylogeny>();
 229             final List<String> names10 = new ArrayList<String>();
 230             phylogenies10.add( p10 );
 231             names10.add( "A" );
 232             names10.add( "B" );
 233             names10.add( "N" );
 234             names10.add( "O" );
 235             final CoverageCalculationOptions options10 = new ExternalNodeBasedCoverageMethodOptions( "org.forester.pccx.BranchCountingBasedScoringMethod" );
 236             final CoverageCalculator cc10 = CoverageCalculator.getInstance( new ExternalNodeBasedCoverageMethod(),
 237                                                                             options10 );
 238             cc10.calculateCoverage( phylogenies10, names10, true );
 239         }
 240         catch ( final Exception e ) {
 241             e.printStackTrace( System.out );
 242             return false;
 243         }
 244         return true;
 245     }
 246 }