Adding Graphs

>>The problem is however that not all the x-values are the same (but
>>they are ordered from low to high), so you can not simply add
>>the corresponding y-values
???  What is your add algorithm?  Isn't it just add up all the x's to get a total x and add up all the y's to get a total y?

No. The x-values represent discrete points on the x axis (something like a time axis) that are not the same for all the graphs.

Suppose that the following are (x,y) points on the first graph:

(0,0) (1,2) (3,3) (5,6) (9,4)

and these are (x,y) points on the second graph:

(0,0) (2,3) (3,5) (7,7)

then the TotalGraph will look something like this:

(0,0) (1,2) (2,5) (3,8) (5,11) (7,12) (9,9)

Is this is not clear, I can try to draw a picture and e-mail it

Yes. I can see how this will work with 2 graphs, but what about 10 or 20? (That's the amount of graphs (varying) I have to use to update the total)  It'll help a lot if you can give some code to illustrate

I forgot one point.  (maybe I didn't think of it). if a point in the source is not in the destination, then it must be added to the destination.  That is, it would be inserted into the destination's series of points.  Then to make this work you start the total out as a graph that has no points. You add the first one onto it (this should make it a copy of the first one) then you add the 2nd one onto it, then the third and so on.

The function would be like

Add(Graph &D,const Graph &S)
{
   int Di = 0
   int Si = 0;

   while (Si < S.Points)
   {
       if (Di < D.Points)
      {
         double Dx = D.x[Di];
         double Sx = S.x[Si];

         if (Dx == Sx)  // If 2 points have same X.
         {
             D.y[Di] += S.y[Si]; // Add points.
            ++Di;
            ++Si;
         }
         else if (Dx < Sx)  // If destination x is less than source,
         {
             ++Di // Skip this point in the dest.
         }
         else
        {
            // insert S's point Si into D.
            ++Di;
            ++Si;
         }
      }
     else
     {
            // insert S's point Si into D.
            ++Si;
      }
   }
}


I hope that helps.

Did this help?

Despite all these textbooks representing a graph as a matrix, I think the representation is poor and inflexible (as you are trying to perform a simple task of combining the edges in two graphs).

Although it is slightly more complex than the matrix rep or the adjacency list representation, this is how I like to do my graphs (in pseudocode for now):

class Node {
public:
   Node(string id);  // constructs a node with a name
   string name();    // returns the node name
private:
   string identifier;
}

class Edge {
public:
   Edge(Node *a, Node *b);  // creates an edge from a to b
   string first();  // returns the name of the first node (x)
   string second(); // returns the name of the second node (y)
private:
   Node *x;
   Node *y;
}

class Graph {
public:
   Graph();
   void add_node(string id);
   void add_edge(string a, string b);
   // and so on
private:
   set<Node*> node_set;
   set<Edge*> edge_set;
   map <string, Node*> node_names;
}

void Graph::add_node(string id) {
   Node* new_node = new Node(id);
   node_set.insert(new_node);
   node_names[id] = new_node;
}

void Graph::add_edge(string a, string b)
   Node *first_node = node_names[a];
   Node *second_node = node_names[b];
   Edge *new_edge = new Edge(first_node, second_node);
   edge_set.insert(new_edge);
}

void Graph::combine(Graph g) {
   // all we have to do is do a union on the node and edge sets
}

---

Anyways, this representation follows closer to a mathematical definition of a graph G(V, E) where V is a set of nodes and E is a set of edges.

Let me know if you are interested in more details.

Thanks for your input VEngineer. I'll accept Nietod's answer, but I like your idea. I'll have a look at it, and if I have any other questions, I'll let you know.