struct Graph* makeGraph(){
	struct Graph* g = (struct Graph*) malloc(sizeof(struct Graph));
	scanf("%d",&g->V);

	scanf("%d",&g->E);
	
	int i =0, to=0, from=0, start=0;
	
	g->v_list = (struct Vertex**)malloc(sizeof(struct Vertex*)*(g->V+1));
	
	for(i = 1;i<=g->V;i++){
		g->v_list[i] = (struct Vertex*) malloc(sizeof(struct Vertex));
		g->v_list[i]->v  = i;
		g->v_list[i]->cost = 0;
		g->v_list[i]->visited = 0;
	}
	
	for( i =1;i<=g->E;i++){
		scanf("%d", &from);
		scanf("%d",&to);
		
		if(from<=g->V && to<=g->V && from >=1 && to>=1){
			struct Edge* e = makeEdge(g->v_list[from],g->v_list[to]);
			struct Edge* e2 = makeEdge(g->v_list[to],g->v_list[from]);
		/* add the edge to the adj_list */
		/* in undirected graph, every vertex has its own edge */
			g->v_list[from]->adj_list = add_edge(e,g->v_list[from]->adj_list);
			g->v_list[to]->adj_list = add_edge(e2,g->v_list[to]->adj_list);
		}
	}
	scanf("%d",&g->start);
	return g;
}
// Recursive Delaunay Triangulation Procedure
// Contains modifications for axis-switching division.
void CDelaunay::build(int lo, int hi, EdgePointer *le, EdgePointer *re, int rows)
{
  EdgePointer a, b, c, ldo, rdi, ldi, rdo, maxx, minx;
  int split, lowrows;
  int low, high;
  SitePointer s1, s2, s3;
  low = lo;
  high = hi;

  if ( low < (high-2) ) {
    // more than three elements; do recursion
    minx = sp[low];
    maxx = sp[high];
    if (rows == 1) {    // time to switch axis of division
      spsorty( sp, low, high);
      rows = 65536;
    }
    lowrows = rows/2;
    split = low - 1 + (int)
      (0.5 + ((double)(high-low+1) * ((double)lowrows / (double)rows)));
    build( low, split, &ldo, &ldi, lowrows );
    build( split+1, high, &rdi, &rdo, (rows-lowrows) );
    doMerge(&ldo, ldi, rdi, &rdo);
    while (orig(ldo) != minx) {
      ldo = rprev(ldo);
    }
    while (orig(rdo) != maxx) {
      rdo = (SitePointer) lprev(rdo);
    }
    *le = ldo;
    *re = rdo;
  }
  else if (low >= (high - 1)) { // two or one points
    a = makeEdge(sp[low], sp[high]);
    *le = a;
    *re = (EdgePointer) sym(a);
  } else { // three points
    // 3 cases: triangles of 2 orientations, and 3 points on a line
    a = makeEdge((s1 = sp[low]), (s2 = sp[low+1]));
    b = makeEdge(s2, (s3 = sp[high]));
    splice((EdgePointer) sym(a), b);
    if (ccw(s1, s3, s2)) {
      c = connectLeft(b, a);
      *le = (EdgePointer) sym(c);
      *re = c;
    } else {
      *le = a;
      *re = (EdgePointer) sym(b);
      if (ccw(s1, s2, s3)) {
        // not colinear
        c = connectLeft(b, a);
      }
    }
  }
}
Exemplo n.º 3
0
/*
 *构造一个位置为point的新的顶点,并构造vertex指向新顶点的边
 *@param[in] vertex 顶点
 *@param[in] point 新生成的顶点位置
 *@param[in] loop 当前环
 *@return 新生成的半边
 */
Half_Edge* EulerOperator::mev(Vertex* vertex,Point point,Loop* loop)
{
	Vertex* vertex2 = new Vertex;
	vertex2->point = point;

	Edge* edge  = makeEdge(vertex,vertex2);
	Half_Edge* he1 = edge->he1;
	Half_Edge* he2 = edge->he2;

	//将半边插入环中
	he1->loop = loop;
	he2->loop = loop;

	if (loop->he==NULL)
	{
		loop->he = he1;
		he2->next = he1;
		he1->prev = he2;
	} 
	else
	{
		Half_Edge* he = loop->he;
		while(he->next->ve1!=vertex) he = he->next;

		he2->next = he->next;
		he1->prev = he;
		he->next->prev = he2;
		he->next = he1;
	}

	insertEdge(loop->face->solid,edge);

	return he1;
}
EdgePointer CDelaunay::connectRight(EdgePointer a, EdgePointer b)
{
  EdgePointer ans;
  ans = makeEdge(dest(a), orig(b));
  splice(ans, (EdgePointer) sym(a));
  splice((EdgePointer) sym(ans), (EdgePointer) oprev(b));
  return(ans);
}
EdgePointer CDelaunay::connectLeft(EdgePointer a, EdgePointer b)
{
  EdgePointer ans;
  ans = makeEdge(dest(a), orig(b));
  splice(ans, (EdgePointer) lnext(a));
  splice((EdgePointer) sym(ans), b);
  return(ans);
}
Exemplo n.º 6
0
Edge *Subdivision::connect(Edge *a, Edge *b)
{
    Edge *e = makeEdge();
    splice(e, a->Lnext());
    splice(e->Sym(), b);
    e->EndPoints(a->Dest(), b->Org());

    return e;
}
Exemplo n.º 7
0
Arquivo: edge.cpp Projeto: dose78/FRPA
QuadEdge *connect( QuadEdge *a, QuadEdge *b ) {
  QuadEdge *e = makeEdge();
  e->setOrg( a->Dest() );
  e->setDest( b->Org() );
  splice( e, a->Lnext() );
  splice( e->Sym(), b );

  return e;
}
Exemplo n.º 8
0
void BMEsplitEdge(meTree *T, meNode *v, meEdge *e, double **A)
{
  meEdge *newPendantEdge;
  meEdge *newInternalEdge;
  meNode *newNode;
  char nodeLabel[NODE_LABEL_LENGTH];
  char edgeLabel1[EDGE_LABEL_LENGTH];
  char edgeLabel2[EDGE_LABEL_LENGTH];
  sprintf(nodeLabel,"I%d",T->size+1);
  sprintf(edgeLabel1,"E%d",T->size);
  sprintf(edgeLabel2,"E%d",T->size+1);
  

  /*make the new meNode and edges*/
  newNode = makeNewNode(nodeLabel,T->size+1);
  newPendantEdge = makeEdge(edgeLabel1,newNode,v,0.0);
  newInternalEdge = makeEdge(edgeLabel2,newNode,e->head,0.0);

  /*update the matrix of average distances*/
  BMEupdateAveragesMatrix(A,e,v,newNode);


  /*put them in the correct topology*/


  newNode->parentEdge = e;
  e->head->parentEdge = newInternalEdge;
  v->parentEdge = newPendantEdge;
  e->head = newNode;

  T->size = T->size + 2;    

  if (e->tail->leftEdge == e) 
    /*actually this is totally arbitrary and probably unnecessary*/
    {
      newNode->leftEdge = newInternalEdge;
      newNode->rightEdge = newPendantEdge;
    }
  else
    {
      newNode->leftEdge = newInternalEdge;
      newNode->rightEdge = newPendantEdge;
    }
}
Exemplo n.º 9
0
int main(int argc, char* argv[]){
  welcomeScreen();
  puts("\nLine:\tFrom:\t\t\tTo:\t\t\tTravel time:\n");
  char* test = argv[1];
  Edge new_edge = allocate();
  makeEdge(test, new_edge);
  printf("%s\t%s\t%s\t%s\n", new_edge->bus_line, (new_edge)->travel_from->name, (new_edge)->travel_to->name, (new_edge)->travel_time);

  return 0;
}
Exemplo n.º 10
0
void CqParseTreeViz::visitChildren(T& node)
{
	IqParseNode* child = static_cast<IqParseNode*>(
			node.GetInterface(ParseNode_Base))->pChild();
	while(child != NULL)
	{
		makeEdge(node, *child);
		child->Accept(*this);
		child = child->pNextSibling();
	}
}
Exemplo n.º 11
0
void CqParseTreeViz::Visit(IqParseNodeShader& node)
{
	setNodeProperty(node, "label", boost::format(
			"{%s shader \\\"%s\\\" | {<args> args | <code> code } }")
			% node.strShaderType() % node.strName());
	setNodeProperty(node, "fillcolor", functionColor);
	setNodeProperty(node, "shape", "record");
	IqParseNode* code = static_cast<IqParseNode*>(
			node.GetInterface(ParseNode_Base))->pChild();
	if(code)
	{
		IqParseNode* args = code->pNextSibling();
		if(args)
		{
			makeEdge(node, *args, "args");
			args->Accept(*this);
		}
		makeEdge(node, *code, "code");
		code->Accept(*this);
	}
}
Exemplo n.º 12
0
void Subdivision::initMesh(const Vec2& A,const Vec2& B,
			   const Vec2& C,const Vec2& D)
{
    Vec2& a = A.clone();
    Vec2& b = B.clone();
    Vec2& c = C.clone();
    Vec2& d = D.clone();

    Edge *ea = makeEdge();
    ea->EndPoints(a, b);

    Edge *eb = makeEdge();
    splice(ea->Sym(), eb);
    eb->EndPoints(b, c);

    Edge *ec = makeEdge();
    splice(eb->Sym(), ec);
    ec->EndPoints(c, d);

    Edge *ed = makeEdge();
    splice(ec->Sym(), ed);
    ed->EndPoints(d, a);
    splice(ed->Sym(), ea);

    Edge *diag = makeEdge();
    splice(ed->Sym(),diag);
    splice(eb->Sym(),diag->Sym());
    diag->EndPoints(a,c);

    startingEdge = ea;

    first_face = NULL;

    makeFace(ea->Sym()).update(*this);
    makeFace(ec->Sym()).update(*this);

}
Exemplo n.º 13
0
void CqParseTreeViz::makeFunctionGraph(const IqFuncDef& funcDef)
{
	// Only try to display graphs of user-defined functions.
	if(funcDef.fLocal())
	{
		setNodeProperty(funcDef, "label",
				boost::format("{%s | {<args> args|<code> code}}")
				% funcDef.strName());
		setNodeProperty(funcDef, "fillcolor", functionColor);
		setNodeProperty(funcDef, "shape", "record");
		const IqParseNode* args = funcDef.pArgs();
		if(args)
		{
			makeEdge(funcDef, *args, "args");
			const_cast<IqParseNode*>(args)->Accept(*this);
		}
		const IqParseNode* code = funcDef.pDef();
		if(code)
		{
			makeEdge(funcDef, *code, "code");
			const_cast<IqParseNode*>(code)->Accept(*this);
		}
	}
}
Exemplo n.º 14
0
/*
 *构造顶点ve1到ve2的一条边,同时构造一个新面
 *注意当前loop的走向变为ve1->ve2,新面loop的走向为ve2->ve1
 *@param[in] ve1 顶点1
 *@param[in] ve2 顶点2
 *@param[in] loop 当前环
 *@return 新生成的面
 */
Face* EulerOperator::mef(Vertex* ve1,Vertex* ve2,Loop* loop)
{
	Edge* edge  = makeEdge(ve1,ve2);
	Half_Edge* he1 = edge->he1;
	Half_Edge* he2 = edge->he2;

	//创建新环
	Loop* loop2 = new Loop;
	Half_Edge *tmpHe1,*tmpHe2;
	Half_Edge* he = loop->he;

	while(he->ve1!=ve1) he=he->next;
	tmpHe1 = he;
	while(he->ve1!=ve2) he=he->next;
	tmpHe2 = he;

	tmpHe1->prev->next = he1;
	he1->prev = tmpHe1->prev;
	he2->next = tmpHe1;
	tmpHe1->prev = he2;

	tmpHe2->prev->next = he2;
	he2->prev = tmpHe2->prev;
	he1->next = tmpHe2;
	tmpHe2->prev = he1;

	loop->he = he1;
	he1->loop = loop;
	loop2->he = he2;
	he2->loop = loop2;

	//创建新面
	Face* face = new Face;
	Solid* solid = loop->face->solid;

	insertEdge(solid,edge);
	insertFace(solid,face);
	insertLoop(face,loop2);

	return face;
}
Exemplo n.º 15
0
graph* makeGraph(int v , int e){
  graph *temp = new graph;
  int i , j , k,sour , dest,wei,p;
  vertex *t;
  temp->noofedges = e;
  temp->noofvertex = v;
  temp->v = new vertex*[v];
  temp->e = new edge*[e];
  for(i = 0  ; i < v ; i ++){
    t = makeVertex(i);
    if(t == NULL){
      cout<<"Error Occured";

    }
    temp->v[i] = t;
  }
  cout<<"Enter 0 if weighted otherwise 1"<<endl;
  cin>>j;
  cout<<"Enter 0 if directed otherwise 1"<<endl;
  cin>>p;
  cout<<"Enter the source and destination of edges (between 0 and no. of the edge - 1):- "<<endl;
  for(i = 0 ; i < e; i++){
        cin>>sour>>dest;
        if(j)
          wei = 0;
        else
          cin>>wei;
        k = insertAdj(temp->v[sour] , temp->v[dest] , wei);
        if(p)
          k = insertAdj(temp->v[dest] , temp->v[sour] , wei);
        if(k)
            cout<<"Error in making adjacentylist  ";
        temp->e[i] = makeEdge(temp->v[sour] , temp->v[dest] , wei);

    }
	return temp;
  }
Exemplo n.º 16
0
	void addEdge(int u, int v, int w)
	{
		Edge *e1 = makeEdge(u, v, w),
			 *e2 = makeEdge(v, u, 0);
		e1->inv = e2, e2->inv = e1;
	}
Exemplo n.º 17
0
void addEdge(int u, int v, int c)
{
	edge_t *e1 = makeEdge(u, v, c), *e2 = makeEdge(v, u, 0);
	e1->inverse = e2, e2->inverse = e1;
}/*}}}*/
Exemplo n.º 18
0
void addEdge(int u, int v, int id) {
	Edge *e1 = makeEdge(u, v, id),
		 *e2 = makeEdge(v, u, id);
	e1->inv = e2, e2->inv = e1;
}
Exemplo n.º 19
0
void Solve::addEdge(int u, int v, Flow_t cap)
{
	Edge *e1 = makeEdge(u, v, cap),
		 *e2 = makeEdge(v, u, 0);
	e1->inverse = e2, e2->inverse = e1;
}
Exemplo n.º 20
0
	void addEdge(int u, int v, int w) {
		Edge *e1 = makeEdge(u, v, w),
			 *e2 = makeEdge(v, u, w);
		e1->inv = e2, e2->inv = e1;
		e2->isRev = true;
	}
Exemplo n.º 21
0
void Solve::addEdge(int u, int v)
{
	Edge *e1 = makeEdge(u, v),
		 *e2 = makeEdge(v, u);
	e1->inverse = e2, e2->inverse = e1;
}
Exemplo n.º 22
0
Edge *Subdivision::spoke(Vec2& x, Edge *e)
{
    Triangle *new_faces[4];
    int facedex = 0;

    //
    // NOTE: e is the edge returned by locate(x)
    //

    if ( (x == e->Org()) || (x == e->Dest()) ) {
        // point is already in the mesh
	//
#ifdef _INC_IOSTREAM
        std::cerr << "WARNING: Tried to reinsert point: " << x << std::endl;
	std::cerr << "         org: " << e->Org() << std::endl;
	std::cerr << "        dest: " << e->Dest() << std::endl;
#endif
        return NULL;
    }

    Edge *boundary_edge = NULL;

    Triangle *lface = e->Lface();
    lface->dontAnchor(e);
    new_faces[facedex++] = lface;

    if( onEdge(x,e) )
    {
	if( ccwBoundary(e) ) {
	    //
	    // e lies on the boundary
	    // Defer deletion until after new edges are added.
	    boundary_edge = e;
	}
	else {
	    Triangle *sym_lface = e->Sym()->Lface();
	    new_faces[facedex++] = sym_lface;
	    sym_lface->dontAnchor(e->Sym());


	    e = e->Oprev();
	    deleteEdge(e->Onext());
	}
    }
    else
    {
	// x lies within the Lface of e
    }

    Edge *base = makeEdge(e->Org(), x.clone());

    splice(base, e);

    startingEdge = base;
    do {
	base = connect(e, base->Sym());
	e = base->Oprev();
    } while( e->Lnext() != startingEdge );

    if( boundary_edge )
	deleteEdge(boundary_edge);

    // Update all the faces in our new spoked polygon.
    // If point x on perimeter, then don't add an exterior face


    base = boundary_edge ? startingEdge->Rprev() : startingEdge->Sym();
    do {
	if( facedex )
	    new_faces[--facedex]->reshape(base);
	else
	    makeFace(base);

	base = base->Onext();

    } while( base != startingEdge->Sym() );

    return startingEdge;
}
/********************************************** MAIN FUNCTION *************************************************/
int main()
{
	int v, i, j, index1, index2, integers1[1000] = {0}, integers2[1000] = {0}, number1, number2;
	char start[100], key[100], s[100];
	scanf("%s", s);
	v = checkFloat(s);
	getchar();
	if(v < 0 || v > 1000 || v == -1)
	{
		printf("INVALID INPUT\n");
		return 0;
	}

	struct Graph *graph = makeGraph(v);

	for(i = 0; i < 10000; i++)
	{
		visited[i] = 0;
	}

	char input[1000][1000], weight[1000][1000];
	for(i = 0; i < v; i++)
	{
		scanf("%[^\n]s", input[i]);
		getchar();
	}

	for(i = 0; i < v; i++)
	{
		scanf("%[^\n]s", weight[i]);
		getchar();
	}

	for(i = 0; i < v; i++)
	{
		index1 = convertInput(input[i], integers1);
		index2 = convertInput(weight[i], integers2);

		if(index1 == -1 || index2 == -1)
		{
			printf("INVALID INPUT\n");
			return 0;
		}

		for(j = 0; j < index2; j++)
		{
			if(integers2[j] < 0 || integers2[j] > 10000)
			{
				printf("INVALID INPUT\n");
				return 0;
			}
		}
		
		if(index1 > 0)
		{
			if(isSorted(integers1, index1) == 0)
			{
				printf("INVALID INPUT\n");
				return 0;
			}
		}

		for(j = 0; j < index1; j++)
		{
			if(integers1[j] < 0 || integers1[j] > (v - 1))
			{
				printf("INVALID INPUT\n");
				return 0;
			}
			makeEdge(graph, i, integers1[j], integers2[j]);
		}
	}
	
	while(1)
	{
		char choice[5];
		scanf("%s", choice);
		if(strcmp(choice, "apsp") == 0)
		{
			scanf("%s", start);
			number1 = checkFloat(start);
			if(number1 < 0 || number1 > (v - 1))
			{
				printf("INVALID INPUT\n");
				return 0;
			}

			dijkstra(graph, number1);
			for(i = 0; i < graph->v; i++)
			{
				if(min_dist_array[i] != 50000)
				{
					printf("%d ", min_dist_array[i]);
				}
				else
				{
					printf("INF ");
				}
			}
			printf("\n");
		}
		else if(strcmp(choice, "sssp") == 0)
		{
			scanf("%s %s", start, key);
			number1 = checkFloat(start);
			if(number1 < 0 || number1 > (v - 1))
			{
				printf("INVALID INPUT\n");
				return 0;
			}

			number2 = checkFloat(key);
			if(number2 < 0 || number2 > (v - 1))
			{
				printf("INVALID INPUT\n");
				return 0;
			}
			dijkstra(graph, number1);
			if(min_dist_array[number2] != 50000)
			{
				printf("%d", min_dist_array[number2]);
			}
			else
			{
				printf("UNREACHABLE");
			}
			printf("\n");
		}
		else if(strcmp(choice, "stop") == 0)
		{
			break;
		}

		else 
		{
			printf("ENTER CORRECT CHOICE\n");
		}
	}
}
Exemplo n.º 24
0
int main(void)
{
    while(scanf("%hd %d", &verts, &edges) != -1)
    {
        for(short int v = 0; v < verts; ++ v)
        {
            tree[v].clear();
            repr[v] = v;
            for(short int v2 = 0; v2 < verts; ++ v2)
                longest[v][v2] = -1;
        }

        for(int c = 0; c <= max; ++ c)
            sort[c].clear();

        max = 0;
        for(int e = 0; e < edges; ++ e)
        {
            scanf("%hd %hd %d", &start, &end, &cost);
            sort[cost].push_back(makeEdge(start - 1, end - 1));
            max = std::max(max, cost);
        }

        result = 0;
        best = 0;
        count = 0;
        for(int c = 0; c <= max && count < verts - 1; ++ c)
            for(unsigned int e = 0; e < sort[c].size(); ++ e)
            {
                int &act = sort[c][e];
                if(unionUnion(edgeFirst(act), edgeSecond(act)))
                {
                    tree[edgeFirst(act)].push_back(makeCostEdge(c, edgeSecond(act)));
                    tree[edgeSecond(act)].push_back(makeCostEdge(c, edgeFirst(act)));
                    ++ count;
                    result += c;
                }
            }

        if(count != verts - 1)
        {
            puts("disconnected");
            continue;
        }

        for(int v = 0; v < verts; ++ v)
            findLongest(v, v);

        for(int c = 0; c <= max; ++ c)
            for(unsigned int e = 0; e < sort[c].size(); ++ e)
            {
                int &act = sort[c][e];
                tmp = c + longest[edgeFirst(act)][edgeSecond(act)];
                if(tmp > best)
                    best = tmp;
            }

        printf("%d\n", result - best);
    }

    return 0;
}
Exemplo n.º 25
0
meTree *BMEaddSpecies(meTree *T,meNode *v, double **D, double **A) 
     /*the key function of the program addSpeices inserts
       the meNode v to the meTree T.  It uses testEdge to see what the relative
       weight would be if v split a particular edge.  Once insertion point
       is found, v is added to T, and A is updated.  Edge weights
       are not assigned until entire meTree is build*/

{
  meTree *T_e;
  meEdge *e; /*loop variable*/
  meEdge *e_min; /*points to best meEdge seen thus far*/
  double w_min = 0.0;   /*used to keep track of meTree weights*/
  
  /*initialize variables as necessary*/
  
  /*CASE 1: T is empty, v is the first node*/
  if (NULL == T)  /*create a meTree with v as only vertex, no edges*/
    {
      T_e = newTree();
      T_e->root = v;  
      /*note that we are rooting T arbitrarily at a leaf.  
	T->root is not the phylogenetic root*/
      v->index = 0;
      T_e->size = 1;
      return(T_e);      
    }
  /*CASE 2: T is a single-vertex tree*/
  if (1 == T->size)
	{
	  v->index = 1;
	  e = makeEdge("",T->root,v,0.0);
	  sprintf(e->label,"E1");
	  A[v->index][v->index] = D[v->index2][T->root->index2];
	  T->root->leftEdge = v->parentEdge = e;
	  T->size = 2;
	  return(T); 
	}
  /*CASE 3: T has at least two nodes and an edge.  Insert new node
    by breaking one of the edges*/
  
  v->index = T->size;
  BMEcalcNewvAverages(T,v,D,A);
  /*calcNewvAverages will update A for the row and column 
    include the meNode v.  Will do so using pre-existing averages in T and
    information from A,D*/
  e_min = T->root->leftEdge;
  e = e_min->head->leftEdge;
  while (NULL != e)
    {
      BMEtestEdge(e,v,A); 
      /*testEdge tests weight of meTree if loop variable 
	e is the meEdge split, places this value in the e->totalweight field */
      if (e->totalweight < w_min)
	{
	  e_min = e;
	  w_min = e->totalweight;
	}
      e = topFirstTraverse(T,e);
    }
  /*e_min now points at the meEdge we want to split*/
  if (verbose)
    
    printf("Inserting %s between %s and %s on %s\n",v->label,e_min->tail->label,
	   e_min->head->label,e_min->label);
  BMEsplitEdge(T,v,e_min,A);
  return(T);
}
Exemplo n.º 26
0
node *decodeNewickSubtree(char *treeString, tree *T, int *uCount)
{
  node *thisNode;
  node *centerNode;
  double thisWeight;
  edge *thisEdge;
//  char label[MAX_LABEL_LENGTH];
  char stringWeight[MAX_LABEL_LENGTH];
  int state;
  int i = 0;
  int j;
  int left,right;
  int parcount;
//  snprintf(label,14,"Default_Label\0");
  left = right = 0;
  parcount = 0;
  state = ReadOpenParenthesis;
  if('(' == treeString[0])
    parcount++;
  //centerNode = makeNode(label,NULL,nodeCount++);
  centerNode = makeNode("",NULL,nodeCount++);
  T->size++;
  while(parcount > 0)
    {
      while(whiteSpace(treeString[i]))
	i++;
      switch(state)
	{
	case(ReadOpenParenthesis):
	  if('(' != treeString[0])
	    {
	      Rprintf("Error reading subtree.\n");
	      exit(0);
	    }
	  i++;
	  state = ReadSubTree;
	  break;
	case(ReadSubTree):
	  if('(' == treeString[i])  /*if treeString[i] is a left parenthesis,
				      we scan down the string until we find its partner.
				      the relative number of '('s vs. ')'s is counted
				      by the variable parcount*/
	    {
	      left = i++;
	      parcount++;
	      while(parcount > 1)
		{
		  while (('(' != treeString[i]) && (')' != treeString[i]))
		    i++;  /*skip over characters which are not parentheses*/
		  if('(' == treeString[i])
		    parcount++;
		  else if (')' == treeString[i])
		    parcount--;
		  i++;
		}  /*end while */
	      right = i;  /*at this point, the subtree string goes from
			    treeString[left] to treeString[right - 1]*/
	      thisNode = decodeNewickSubtree(treeString + left,T,uCount);  /*note that this
								      step will put
								      thisNode in T*/
	      i = right;  /*having created the node for the subtree, we move
			    to assigning the label for the new node.
			    treeString[right] will be the start of this label */
	    } /* end if ('(' == treeString[i]) condition */
	  else
	    {
	      //thisNode = makeNode(label,NULL,nodeCount++);
	      thisNode = makeNode("",NULL,nodeCount++);
	      T->size++;
	    }
	  state = ReadLabel;
	  break;
	case(ReadLabel):
	  left = i;  /*recall "left" is the left marker for the substring, "right" the right*/
	  if (':' == treeString[i])   /*this means an internal node?*/
	    {
	      //sprintf(thisNode->label,"I%d",(*uCount)++);
	      //snprintf(thisNode->label,MAX_LABEL_LENGTH,"I%d",(*uCount)++);
	      (*uCount)++;
	      right = i;
	    }
	  else
	    {
	      while((':' != treeString[i]) && (',' != treeString[i]) && (')' != treeString[i]))
		i++;
	      right = i;
	      j = 0;
	      for(i = left; i < right;i++)
		if(!(whiteSpace(treeString[i])))
		  thisNode->label[j++] = treeString[i];
	      thisNode->label[j] = '\0';
	    }
	  if(':' == treeString[right])
	    state = ReadWeight;
	  else
	    {
	      state = AddEdge;
	      thisWeight = 0.0;
	    }
	  i = right + 1;
	  break;
	case(ReadWeight):
	  left = i;
	  while
	    ((',' != treeString[i]) && (')' != treeString[i]))
	    i++;
	  right = i;
	  j = 0;
	  for(i = left; i < right; i++)
	    stringWeight[j++] = treeString[i];
	  stringWeight[j] = '\0';
	  thisWeight = atof(stringWeight);
	  state=AddEdge;
	  break;
	case(AddEdge):
	  //thisEdge = makeEdge(label,centerNode,thisNode,thisWeight);
	  thisEdge = makeEdge("",centerNode,thisNode,thisWeight);
	  thisNode->parentEdge = thisEdge;
	  if (NULL == centerNode->leftEdge)
	    centerNode->leftEdge = thisEdge;
	  else if (NULL == centerNode->rightEdge)
	    centerNode->rightEdge = thisEdge;
	  else if (NULL == centerNode->middleEdge)
	    centerNode->middleEdge = thisEdge;
	  else
	    {
	      Rprintf("Error: node %s has too many (>3) children.\n",centerNode->label);
	      exit(0);
	    }
	  //sprintf(thisEdge->label,"E%d",edgeCount++);
	  //snprintf(thisEdge->label,MAX_LABEL_LENGTH,"E%d",edgeCount++);
	  edgeCount++;
	  i = right + 1;
	  if (',' == treeString[right])
	    state = ReadSubTree;
	  else
	    parcount--;
	  break;
	}
    }
  return(centerNode);
}