added abs() to weighted and unweighted to account for negative branch lengths

diff --git a/unweighted.cpp b/unweighted.cpp
index 405dfd2b3feaf4c1a5327526936a7baaaa4aba0a..3694d263fb1039ea5208926301b7bd18a38875a3 100644 (file)
--- a/unweighted.cpp
+++ b/unweighted.cpp
@@ -64,11 +64,11 @@ EstOutput Unweighted::getValues(Tree* t) {
                                        //if i's children are from the same group then i's pcount size will be 1 
                                        //if copyIpcount.size() = 0 they are from a branch that is entirely from a group the user doesn't want
                                        if (copyIpcount.size() == 0) { }
-                                       else if ((t->tree[i].getBranchLength() != -1) && (copyIpcount.size() == 1)) {  UniqueBL += t->tree[i].getBranchLength();        }
+                                       else if ((t->tree[i].getBranchLength() != -1) && (copyIpcount.size() == 1)) {  UniqueBL += abs(t->tree[i].getBranchLength());   }
                        
                                        //add i's BL to total if it is from the groups the user wants
                                        if ((t->tree[i].getBranchLength() != -1) && (copyIpcount.size() != 0)) {  
-                                               totalBL += t->tree[i].getBranchLength(); 
+                                               totalBL += abs(t->tree[i].getBranchLength()); 
                                        }
                        
                                        /**********************************************************************/
@@ -78,16 +78,16 @@ EstOutput Unweighted::getValues(Tree* t) {
                                        if (t->tree[rc].getRChild() == -1) {
                                                //if rc is a valid group and rc has a BL
                                                if ((inUsersGroups(t->tree[rc].getGroup(), groups) == true) && (t->tree[rc].getBranchLength() != -1)) {
-                                                       UniqueBL += t->tree[rc].getBranchLength();
-                                                       totalBL += t->tree[rc].getBranchLength(); 
+                                                       UniqueBL += abs(t->tree[rc].getBranchLength());
+                                                       totalBL += abs(t->tree[rc].getBranchLength()); 
                                                }
                                        }
                        
                                        if (t->tree[lc].getLChild() == -1) {
                                                //if lc is a valid group and lc has a BL
                                                if ((inUsersGroups(t->tree[lc].getGroup(), groups) == true) && (t->tree[lc].getBranchLength() != -1)) {
-                                                       UniqueBL += t->tree[lc].getBranchLength();
-                                                       totalBL += t->tree[lc].getBranchLength(); 
+                                                       UniqueBL += abs(t->tree[lc].getBranchLength());
+                                                       totalBL += abs(t->tree[lc].getBranchLength()); 
                                                }
                                        }
                        
@@ -138,11 +138,11 @@ EstOutput Unweighted::getValues(Tree* t) {
                                //if i's children are from the same group then i's pcount size will be 1 
                                //if copyIpcount.size() = 0 they are from a branch that is entirely from a group the user doesn't want
                                if (copyIpcount.size() == 0) { }
-                               else if ((t->tree[i].getBranchLength() != -1) && (copyIpcount.size() == 1)) {  UniqueBL += t->tree[i].getBranchLength();        }
+                               else if ((t->tree[i].getBranchLength() != -1) && (copyIpcount.size() == 1)) {  UniqueBL += abs(t->tree[i].getBranchLength());   }
                        
                                //add i's BL to total if it is from the groups the user wants
                                if ((t->tree[i].getBranchLength() != -1) && (copyIpcount.size() != 0)) {  
-                                       totalBL += t->tree[i].getBranchLength(); 
+                                       totalBL += abs(t->tree[i].getBranchLength()); 
                                }
                        
                                /**********************************************************************/
@@ -152,16 +152,16 @@ EstOutput Unweighted::getValues(Tree* t) {
                                if (t->tree[rc].getRChild() == -1) {
                                        //if rc is a valid group and rc has a BL
                                        if ((inUsersGroups(t->tree[rc].getGroup(), groups) == true) && (t->tree[rc].getBranchLength() != -1)) {
-                                               UniqueBL += t->tree[rc].getBranchLength();
-                                               totalBL += t->tree[rc].getBranchLength(); 
+                                               UniqueBL += abs(t->tree[rc].getBranchLength());
+                                               totalBL += abs(t->tree[rc].getBranchLength()); 
                                        }
                                }
                        
                                if (t->tree[lc].getLChild() == -1) {
                                        //if lc is a valid group and lc has a BL
                                        if ((inUsersGroups(t->tree[lc].getGroup(), groups) == true) && (t->tree[lc].getBranchLength() != -1)) {
-                                               UniqueBL += t->tree[lc].getBranchLength();
-                                               totalBL += t->tree[lc].getBranchLength(); 
+                                               UniqueBL += abs(t->tree[lc].getBranchLength());
+                                               totalBL += abs(t->tree[lc].getBranchLength()); 
                                        }
                                }
                        
@@ -252,11 +252,11 @@ EstOutput Unweighted::getValues(Tree* t, string groupA, string groupB) {
                                        //if i's children are from the same group then i's pcount size will be 1 
                                        //if copyIpcount.size() = 0 they are from a branch that is entirely from a group the user doesn't want
                                        if (copyIpcount.size() == 0) { }
-                                       else if ((copyTree->tree[i].getBranchLength() != -1) && (copyIpcount.size() == 1)) {  UniqueBL += copyTree->tree[i].getBranchLength();  }
+                                       else if ((copyTree->tree[i].getBranchLength() != -1) && (copyIpcount.size() == 1)) {  UniqueBL += abs(copyTree->tree[i].getBranchLength());     }
                        
                                        //add i's BL to total if it is from the groups the user wants
                                        if ((copyTree->tree[i].getBranchLength() != -1) && (copyIpcount.size() != 0)) {  
-                                               totalBL += copyTree->tree[i].getBranchLength(); 
+                                               totalBL += abs(copyTree->tree[i].getBranchLength()); 
                                        }
                        
                                        /**********************************************************************/
@@ -266,16 +266,16 @@ EstOutput Unweighted::getValues(Tree* t, string groupA, string groupB) {
                                        if (copyTree->tree[rc].getRChild() == -1) {
                                                //if rc is a valid group and rc has a BL
                                                if ((inUsersGroups(copyTree->tree[rc].getGroup(), groups) == true) && (copyTree->tree[rc].getBranchLength() != -1)) {
-                                                       UniqueBL += copyTree->tree[rc].getBranchLength();
-                                                       totalBL += copyTree->tree[rc].getBranchLength(); 
+                                                       UniqueBL += abs(copyTree->tree[rc].getBranchLength());
+                                                       totalBL += abs(copyTree->tree[rc].getBranchLength()); 
                                                }
                                        }
                        
                                        if (copyTree->tree[lc].getLChild() == -1) {
                                                //if lc is a valid group and lc has a BL
                                                if ((inUsersGroups(copyTree->tree[lc].getGroup(), groups) == true) && (copyTree->tree[lc].getBranchLength() != -1)) {
-                                                       UniqueBL += copyTree->tree[lc].getBranchLength();
-                                                       totalBL += copyTree->tree[lc].getBranchLength(); 
+                                                       UniqueBL += abs(copyTree->tree[lc].getBranchLength());
+                                                       totalBL += abs(copyTree->tree[lc].getBranchLength()); 
                                                }
                                        }
                        
@@ -332,11 +332,11 @@ EstOutput Unweighted::getValues(Tree* t, string groupA, string groupB) {
                                //if i's children are from the same group then i's pcount size will be 1 
                                //if copyIpcount.size() = 0 they are from a branch that is entirely from a group the user doesn't want
                                if (copyIpcount.size() == 0) { }
-                               else if ((copyTree->tree[i].getBranchLength() != -1) && (copyIpcount.size() == 1)) {  UniqueBL += copyTree->tree[i].getBranchLength();  }
+                               else if ((copyTree->tree[i].getBranchLength() != -1) && (copyIpcount.size() == 1)) {  abs(UniqueBL += copyTree->tree[i].getBranchLength());     }
                        
                                //add i's BL to total if it is from the groups the user wants
                                if ((copyTree->tree[i].getBranchLength() != -1) && (copyIpcount.size() != 0)) {  
-                                       totalBL += copyTree->tree[i].getBranchLength(); 
+                                       totalBL += abs(copyTree->tree[i].getBranchLength()); 
                                }
                        
                                /**********************************************************************/
@@ -346,16 +346,16 @@ EstOutput Unweighted::getValues(Tree* t, string groupA, string groupB) {
                                if (copyTree->tree[rc].getRChild() == -1) {
                                        //if rc is a valid group and rc has a BL
                                        if ((inUsersGroups(copyTree->tree[rc].getGroup(), groups) == true) && (copyTree->tree[rc].getBranchLength() != -1)) {
-                                               UniqueBL += copyTree->tree[rc].getBranchLength();
-                                               totalBL += copyTree->tree[rc].getBranchLength(); 
+                                               UniqueBL += abs(copyTree->tree[rc].getBranchLength());
+                                               totalBL += abs(copyTree->tree[rc].getBranchLength()); 
                                        }
                                }
                        
                                if (copyTree->tree[lc].getLChild() == -1) {
                                        //if lc is a valid group and lc has a BL
                                        if ((inUsersGroups(copyTree->tree[lc].getGroup(), groups) == true) && (copyTree->tree[lc].getBranchLength() != -1)) {
-                                               UniqueBL += copyTree->tree[lc].getBranchLength();
-                                               totalBL += copyTree->tree[lc].getBranchLength(); 
+                                               UniqueBL += abs(copyTree->tree[lc].getBranchLength());
+                                               totalBL += abs(copyTree->tree[lc].getBranchLength()); 
                                        }
                                }
                        

diff --git a/weighted.cpp b/weighted.cpp
index fa22716e397c4dddb1dd1ab29e2cd04d40b10311..581078085d4e573ad100dbc48f1ec87d64558efa 100644 (file)
--- a/weighted.cpp
+++ b/weighted.cpp
@@ -39,14 +39,14 @@ EstOutput Weighted::getValues(Tree* t) {
                                                        
                                                //if you have a BL
                                                if(t->tree[index].getBranchLength() != -1){
-                                                       sum += t->tree[index].getBranchLength();
+                                                       sum += abs(t->tree[index].getBranchLength());
                                                }
                                                index = t->tree[index].getParent();
                                        }
                                                
                                        //get last breanch length added
                                        if(t->tree[index].getBranchLength() != -1){
-                                               sum += t->tree[index].getBranchLength();
+                                               sum += abs(t->tree[index].getBranchLength());
                                        }
                                                
                                        //is this sum from a sequence which is in one of the users groups
@@ -85,7 +85,7 @@ EstOutput Weighted::getValues(Tree* t) {
                                                u -= (double) t->tree[i].pcount[globaldata->Groups[l]] / (double) tmap->seqsPerGroup[globaldata->Groups[l]];
                                        }
                                                
-                                       u = abs(u) * t->tree[i].getBranchLength();
+                                       u = abs(u * t->tree[i].getBranchLength());
                                        
                                        //save groupcombs u value
                                        WScore[globaldata->Groups[b]+globaldata->Groups[l]] += u;
@@ -142,14 +142,14 @@ EstOutput Weighted::getValues(Tree* t, string groupA, string groupB) {
                                                        
                                //if you have a BL
                                if(t->tree[index].getBranchLength() != -1){
-                                       sum += t->tree[index].getBranchLength();
+                                       sum += abs(t->tree[index].getBranchLength());
                                }
                                index = t->tree[index].getParent();
                        }
                                                
                        //get last breanch length added
                        if(t->tree[index].getBranchLength() != -1){
-                               sum += t->tree[index].getBranchLength();
+                               sum += abs(t->tree[index].getBranchLength());
                        }
                                                
                        if ((t->tree[v].getGroup() == groupA) || (t->tree[v].getGroup() == groupB)) {
@@ -177,7 +177,7 @@ EstOutput Weighted::getValues(Tree* t, string groupA, string groupB) {
                                u -= (double) t->tree[i].pcount[groupB] / (double) tmap->seqsPerGroup[groupB];
                        }
                                                
-                       u = abs(u) * t->tree[i].getBranchLength();
+                       u = abs(u * t->tree[i].getBranchLength());
                                        
                        //save groupcombs u value
                        WScore[(groupA+groupB)] += u;