/**
* Reads all of the names in a file into an array of
* strings. Each element of the array is a char pointer.
*
* If nStrings is non-NULL, the number of strings is
* returned in nStrings.
*
* The array is always one larger than nStrings elements
* long and the last element is a NULL.
*
* @param fileName Name of file to read
* @param nStrings Optional pointer to integer that will on return contain
* the count of strings read from the file
* @returns A NULL-terminated list of NULL-terminated strings
*/
ListOfStrings
readListOfStrings (const char *fileName, int *nStrings)
{
Tokenizer tok;
void *stringList = NULL;
FILE *f;
char *string;
ListOfStrings array;
size_t numStrings;
f = fopen (fileName, "r");
DEBUG_CHECK (f, "Unable to read file");
tokenizerInit (&tok, tokenizerStreamReader, f);
while (!tokenizerEndOfFile (&tok))
{
string = strdup (tokenizerGetWord (&tok));
listAccumulate (&stringList, &string, sizeof (unsigned char *));
}
fclose (f);
/* Add a terminating NULL */
string = NULL;
listAccumulate (&stringList, &string, sizeof (unsigned char *));
array = (ListOfStrings)listToArray (&stringList, sizeof (unsigned char *), &numStrings);
if (nStrings) *nStrings = numStrings - 1; /* Don't count the NULL */
return array;
}
void subTree(int n,int m,int r,int* & P,int* & Suc1,int* & Suc2,double* & B,string* & Support,string* & Labels,list<int> & P1,list<double> & B1,list<string> & Support1,list<string> &Labels1){
list<int> nodes = sub(r,n,m,P,Suc1,Suc2);
int *tab=new int[nodes.size()];
listToArray(nodes,tab);
sort(tab,(int)nodes.size());
for (int i=0;i<nodes.size();i++){
int j = index(tab,P[tab[i]],(int)nodes.size());
P1.push_back(j);
B1.push_back(B[tab[i]]);
Support1.push_back(Support[tab[i]]);
Labels1.push_back(Labels[tab[i]]);
}
delete[] tab;
}
int main (int argc, char **argv)
{
double scale = 1.;
double width = 80.;
double atom = 1e-8; /* 1e-8 */
double d;
int n;
gatherOptions(argc, argv, &scale, &width, &atom);
doubleList_t *list = NULL;
initList(list);
while (scanf("%lf", &d) == 1) {
addToList(&list, d);
}
double *array;
n = countList(list);
array = listToArray(list, n);
releaseList(list);
stem_leaf(array, n, scale, width, atom);
free(array);
return EXIT_SUCCESS;
}
void extrait_outgroup(string inFile,string outFile,list<string> &outgroups,int nb){
int n;//the number of internal nodes
int m;//the number of branches
int n1,m1;
counting(inFile,n,m,nb);
int *P = new int[m+1];//tableau de predecesseurs
double *B = new double[m+1];//branch lengths
string *Support = new string[m+1];
string* Labels = new string[m+1];
FILE * tree = fopen(inFile.c_str(),"rt");
if (tree==NULL) cout<<"Can not open the tree file"<<endl;
else{
FILE * w = fopen(outFile.c_str(),"wt");
bool rooted=false;
for (int y=1;y<=nb;y++){
if (rooted){
n++;
m++;
}
tree2dataS(tree,n,m,P,B,Support,Labels);
int * Suc1= new int[n];
int * Suc2= new int[n];
computeSuc(P,Suc1,Suc2,m+1,n);
list<int> P1;
list<double> B1;
list<string> Support1;
list<string> Labels1;
list<double> T1;
int s;
if (m==2*n){
rooted=true;
rooted2unrooted(n,m,P,Suc1,Suc2,B,Labels);
m--;
n--;
computeSuc(P,Suc1,Suc2,m+1,n);
}
s= computeSuc_unrooted(P,Suc1,Suc2,m+1,n);
list<int> out;
list<int> in;
for (int i=n;i<=m;i++){
bool flag = true;
for (list<string>::iterator iter=outgroups.begin();iter!=outgroups.end();iter++){
if (Labels[i].compare(*iter)==0){
out.push_back(i);
flag=false;
break;
}
}
if (flag) in.push_back(i);
}
if (out.size()==0){
cout<<"Tree "<<y<<": the tree does not contain any outgroup"<<endl;
exit( EXIT_SUCCESS );
}
else{
int *P_new= new int[m+1];
int *Suc1_new= new int[n];
int *Suc2_new= new int[n];
double *B_new= new double[m+1];
string* Support_new = new string[m+1];
int t=out.front();
int t1=in.front();
if (out.size()==1){
reroot(n,m,t,P,s,Suc1,Suc2,B,Support,P_new,Suc1_new,Suc2_new,B_new,Support_new);
subTree(n,m,P[t],P_new,Suc1_new,Suc2_new,B_new,Support_new,Labels,P1,B1,Support1,Labels1);
int *Po=new int[m];
listToArray(P1,Po);
double *Bo=new double[m];
listToArray(B1,Bo);
string* Supporto=new string[m];
listToArray(Support1,Supporto);
string* Labelso = new string[m];
listToArray(Labels1,Labelso);
int *Suc1o=new int[n];
int *Suc2o=new int[n];
computeSuc(Po,Suc1o,Suc2o,m,n);
newicktree(n,Po,Suc1o,Suc2o,Labelso,Bo,Supporto,w);
delete[] Po;
delete[] Bo;
delete[] Labelso;
delete[] Suc1o;
delete[] Suc2o;
delete[] Supporto;
}
else{
bool flag = false;
while (!flag && P[t]!=-1){
t = P[t];
flag=true;
for (list<int>::iterator ia=out.begin();ia!=out.end();ia++){
int j=*ia;
if (!isAncestor(P,t,j)) {
flag=false;break;
}
}
}//t is lca of outgroups
if (P[t]!=-1){//lca of outgroups is not the root
reroot(n,m,t,P,s,Suc1,Suc2,B,Support,P_new,Suc1_new,Suc2_new,B_new,Support_new);
subTree(n,m,P[t],P_new,Suc1_new,Suc2_new,B_new,Support_new,Labels,P1,B1,Support1,Labels1);
}
else{//lca of outgroups is the root
bool flag = false;
while (!flag && P[t1]!=-1){
t1 = P[t1];
flag=true;
for (list<int>::iterator ia=in.begin();ia!=in.end();ia++){
int j=*ia;
if (!isAncestor(P,t1,j)) {flag=false;break;}
}
}
//t1 is lca of ingroups
if (P[t1]==-1){//lca of ingroups is the root
cout<<"Tree "<<y<<": The outgroups are not separated from the ingroups"<<endl;
exit( EXIT_FAILURE );
}
else{//lca of ingroups is not the root
reroot(n,m,t1,P,s,Suc1,Suc2,B,Support,P_new,Suc1_new,Suc2_new,B_new,Support_new);
subTree(n,m,t1,P_new,Suc1_new,Suc2_new,B_new,Support_new,Labels,P1,B1,Support1,Labels1);
}
}
m1=(int)P1.size()-1;
n1=m1/2;
if ((n1+out.size())==n+1){
int *Po = new int[m1+1];
listToArray(P1,Po);
double *Bo = new double[m1+1];
listToArray(B1,Bo);
string* Supporto = new string[m1+1];
listToArray(Support1,Supporto);
string* Labelso = new string[m1+1];
listToArray(Labels1,Labelso);
int *Suc1o = new int[n1];
int *Suc2o = new int[n1];
computeSuc(Po,Suc1o,Suc2o,m1+1,n1);
newicktree(n1,Po,Suc1o,Suc2o,Labelso,Bo,Supporto,w);
delete[] Po;
delete[] Bo;
delete[] Supporto;
delete[] Labelso;
delete[] Suc1o;
delete[] Suc2o;
}
else {
cout<<"Tree "<<y<<": The outgroups are not separated from the ingroups"<<endl;
exit( EXIT_FAILURE );
}
delete[] P_new;
delete[] Suc1_new;
delete[] Suc2_new;
delete[] B_new;
delete[] Support_new;
}
delete[] Suc1;
delete[] Suc2;
}
}
fclose(tree);
fclose(w);
}
delete[] P;
delete[] B;
delete[] Support;
delete[] Labels;
}
void
sortSubjectsBySimilarityToProbe (char *probe, ListOfStrings subjects, char *distanceMatrix, int *indices)
{
int i, j, nDistances;
DistanceMeasure *distances = NULL;
DistanceMeasure *toSort = NULL;
int nSubjects = countStrings (subjects);
/* If we are using a distance matrix, then we load up the
* list of distances from the probe image. This allows us
* to lookup the distances from the probe quickly
*/
if (distanceMatrix)
{
Tokenizer tok;
FILE *f = fopen (makePath (distanceMatrix, probe), "r");
void *distanceList = NULL;
DEBUG_CHECK_1ARG (f, "Unable to open file %s in scores directory", makePath (distanceMatrix, probe));
tokenizerInit (&tok, tokenizerStreamReader, f);
while (!tokenizerEndOfFile (&tok))
{
DistanceMeasure m;
m.subject = strdup (tokenizerGetWord (&tok));
m.distance = atof (tokenizerGetWord (&tok));
listAccumulate (&distanceList, &m, sizeof (DistanceMeasure));
}
fclose (f);
distances = (DistanceMeasure*) listToArray (&distanceList, sizeof (DistanceMeasure), (size_t*)&nDistances);
}
/* Copy the list of names into the intermediate data structure that allows us to sort the
* subjects by distance to the probe.
*/
toSort = (DistanceMeasure*) malloc (nSubjects * sizeof (DistanceMeasure));
for (j = 0; j < nSubjects; j++)
{
toSort[j].subject = subjects[j];
toSort[j].distance = 0.0;
toSort[j].index = j;
}
/* Read distances between probe and every other image in the subject list.
* As a special case, a subject is said to be infinitely far away from him/herself.
* Random scores are used when a distanceMatrix is not provided */
for (j = 0; j < nSubjects; j++)
{
if (strcmp (subjects[j], probe) == 0) {
/* Probe and subject are the same. Say they are far apart since
* we don't want to treat an image and itself as being two replicates
* of a person */
toSort[j].distance = HUGE;
} else if (distanceMatrix != NULL) {
/* Look for the subject in the list of distances and return assign the
* score */
toSort[j].distance = HUGE;
for (i = 0; i < nDistances; ++i)
if (strcmp (distances[i].subject, toSort[j].subject) == 0)
toSort[j].distance = distances[i].distance;
} else {
/* If we are not using a distance matrix, then choose
* a random value */
toSort[j].distance = ((double) rand()) / RAND_MAX;
}
}
/* Now sort the list by similarity to the probe */
qsort (toSort, nSubjects, sizeof (DistanceMeasure), distanceMeasureComparator);
/* Copy the data back into the subject list or return the permuted indices */
if (indices == NULL)
for (j = 0; j < nSubjects; j++) {
subjects[j] = toSort[j].subject;
}
else
for (j = 0; j < nSubjects; j++) {
indices[j] = toSort[j].index;
}
/* Clean up */
if (distanceMatrix)
{
for (i = 0; i < nDistances; ++i)
free (distances[i].subject);
free (distances);
}
free (toSort);
}
