complearn 0.6.2

data/ext/Quartet.c

@@ -0,0 +1,399 @@
+#include <stdio.h>
+#include <assert.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <malloc.h>
+#include <sys/time.h>
+
+#include "ruby.h"
+#include "Quartet.h"
+
+void printTree(const struct NodeTree *nt)
+{
+  int i, j;
+  printf("Tree size: %d\n", nt->size);
+  for (i = 0; i < nt->size; ++i) {
+    const struct NodeList *cur = &nt->nl[i];
+    for (j = 0; j < cur->size; ++j) {
+      printf("%d->%d, ", i, cur->n[j]);
+    }
+  }
+  printf("\n");
+}
+
+struct NodeTree *newNodeTree(int size)
+{
+  // m2.
+  struct NodeTree *result = (struct NodeTree *) calloc(sizeof(struct NodeTree), 1);
+  result->size = size;
+  // m12.
+  result->nl = (struct NodeList *) calloc(sizeof(struct NodeList), size);
+  return result;
+}
+
+void freeNodeList(struct NodeList *nl)
+{
+  nl->size = 0;
+  // f12.
+  free(nl);
+}
+
+void freeNodeTree(struct NodeTree *nt)
+{
+  freeNodeList(nt->nl);
+  nt->nl = NULL;
+  nt->size = 0;
+  // f2.
+  free(nt);
+}
+
+/* Allocate a new DistMatrix square of side length size, or size*size places */
+struct DistMatrix *newDistMatrix(int size)
+{
+  struct DistMatrix *dm;
+  int i;
+
+  // m3.
+  dm = (struct DistMatrix *) calloc(sizeof(struct DistMatrix), 1);
+  dm->size = size;
+
+  // m4.
+  dm->vals = (weight_t **) calloc(sizeof(weight_t *), size);
+
+  // m5.
+  for (i = 0; i < size; ++i)
+    dm->vals[i] = (weight_t *) calloc(sizeof(weight_t), size);
+
+  return dm;
+}
+
+/* Free a DistMatrix */
+void freeDistMatrix(struct DistMatrix *dm)
+{
+  int i;
+  // f5.
+  for (i = 0; i < dm->size; ++i)
+    free(dm->vals[i]);
+  // f4.
+  free(dm->vals);
+  dm->vals = NULL;
+  // f3.
+  free(dm);
+}
+
+/*
+ * Calculate the cost of quartet q relative to a distance matrix dm
+ * using the formula Cost = LeftSubtreeDistance + RightSubtreeDistance
+ */
+weight_t calculateCost(struct Quartet *q, const struct DistMatrix *dm)
+{
+  int i;
+  for (i = 0; i < 4; ++i)
+    assert(dm->size > q->q[i]);
+  return dm->vals[q->q[0]][q->q[1]] + dm->vals[q->q[2]][q->q[3]];
+}
+
+/*
+ * Create a list of all 3 possible quartet arrangements of four nodes.
+ * Copy these into the area pointed to by result.
+ */
+void makeAllQuartetsFromLabels(int i,int j,int k,int l,
+    const struct DistMatrix *dm, struct Quartet *result)
+{
+  struct Quartet cand[3] = {
+    { 0, { i, j, k, l } },
+    { 0, { i, k, j, l } },
+    { 0, { i, l, j, k } }
+  };
+  int c;
+  for (c = 0; c < 3; ++c) {
+    cand[c].weight = -calculateCost(cand+c, dm);
+    result[c] = cand[c];
+  }
+}
+
+/*
+ * Make just the best quartet possible for this unordered set of four labels.
+ * Copy this into the result area.
+ */
+void makeSingleQuartetFromLabels(int i,int j,int k,int l,
+    const struct DistMatrix *dm, struct Quartet *result)
+{
+  struct Quartet cand[3] = {
+    { 0, { i, j, k, l } },
+    { 0, { i, k, j, l } },
+    { 0, { i, l, j, k } }
+  };
+
+  int c;
+  int flag;
+
+  for (c = 0; c < 3; ++c)
+    cand[c].weight = calculateCost(cand+c, dm);
+
+  /* Bubble-sort the three weights */
+  do {
+    flag = 0;
+    for (c = 0; c < 2; ++c)
+      if (cand[c].weight > cand[c+1].weight) {
+        struct Quartet tmp = cand[c];
+        cand[c] = cand[c+1];
+        cand[c+1] = tmp;
+        flag = 1;
+      }
+  } while (flag == 1);
+  // Make weight equal cost difference between top two candidates
+  cand[0].weight = cand[1].weight - cand[0].weight;
+  *result = cand[0];
+}
+
+/* Return the number of ways to choose k items from a set of n without ordering */
+unsigned int choose(unsigned int n, unsigned int k)
+{
+  int i;
+  int acc = 1;
+  assert(n >= k);
+  for (i = n; i > n-k; i--)
+    acc *= i;
+  for (i = 2; i <= k; i++)
+    acc /= i;
+  return acc;
+}
+
+/*
+ * Make complete (all 3*n) quartet list for this weight matrix.
+ */
+struct QuartetList *makeFullQuartetList(const struct DistMatrix *dm, weight_t *worst, weight_t *best)
+{
+  int i, j, k, l;
+  weight_t wmin, wmax;
+  int m;
+  int c = dm->size;
+  unsigned int curindex = 0;
+  // m6.
+  struct QuartetList *result = (struct QuartetList *) calloc(sizeof(struct QuartetList), 1);
+  result->num = 3 * choose(dm->size, 4);
+  // m7.
+  result->q = (struct Quartet *) calloc(sizeof(struct Quartet), result->num);
+  *worst = *best = 0.0;
+  for (i = 0; i < c; ++i)
+    for (j = i+1; j < c; ++j)
+      for (k = j+1; k < c; ++k)
+        for (l = k+1; l < c; ++l) {
+          makeAllQuartetsFromLabels(i,j,k,l,dm,result->q+curindex);
+          wmin = wmax = result->q[curindex].weight;
+          for (m = 1; m < 3; ++m) {
+            if (wmin > result->q[curindex+m].weight)
+              wmin = result->q[curindex+m].weight;
+            if (wmax < result->q[curindex+m].weight)
+              wmax = result->q[curindex+m].weight;
+          }
+          curindex += 3;
+          *worst += wmin;
+          *best += wmax;
+        }
+  return result;
+}
+
+/*
+ * Make a list of just the best quartets for this distance matrix
+ * This is 1/3 of the size of the full list
+ */
+struct QuartetList *makeBestQuartetList(const struct DistMatrix *dm, weight_t *worst, weight_t *best)
+{
+  int i, j, k, l, c;
+  weight_t total = 0;
+  unsigned int curindex = 0;
+  // m8.
+  struct QuartetList *result = (struct QuartetList *) calloc(sizeof(struct QuartetList), 1);
+  result->num = choose(dm->size, 4);
+  // m9.
+  result->q = (struct Quartet *) calloc(sizeof(struct Quartet), result->num);
+ 	c	= dm->size;
+  for (i = 0; i < c; ++i)
+    for (j = i+1; j < c; ++j)
+      for (k = j+1; k < c; ++k)
+        for (l = k+1; l < c; ++l) {
+          makeSingleQuartetFromLabels(i,j,k,l,dm,result->q+curindex);
+          total += result->q[curindex].weight;
+          curindex += 1;
+        }
+  *worst = 0.0;
+  *best = total;
+  return result;
+}
+
+static qbase_t pop_front(struct NodeList *nl)
+{
+  qbase_t result;
+  assert(nl->size > 0);
+  result = nl->n[0];
+  nl->size -= 1;
+  memmove(nl->n, nl->n+1, sizeof(nl->n[0])*nl->size);
+  return result;
+}
+
+void push_back(struct NodeList *nl, qbase_t which)
+{
+  nl->n[nl->size] = which;
+  nl->size += 1;
+}
+
+/*
+ * Calculate the shortest path map for a given root node.
+ * For a tree of n nodes, the map from r will look like this:
+ * result[r] == r  (only the root node points to itself)
+ * for any other x != r, result[x] is the unique neighboring node whose
+ * distance to r is exactly 1 less than x's.
+ * 
+ */
+void shortestPathTree(qbase_t root, const struct NodeTree *tree, struct NodeList *result)
+{
+  struct NodeList pending;
+  struct NodeList visitted;
+  pending.size = visitted.size = 0;
+  push_back(&pending, root);
+  memset(visitted.n, 0, sizeof(visitted.n[0]) * tree->size);
+  visitted.n[root] = 1;
+  result->n[root] = root;
+  while (pending.size > 0) {
+    qbase_t from = pop_front(&pending);
+    int i;
+    for (i = 0; i < tree->nl[from].size; ++i) {
+      qbase_t cur = tree->nl[from].n[i];
+      if (!visitted.n[cur]) {
+        visitted.n[cur] = 1;
+        push_back(&pending, cur);
+        result->n[cur] = from;
+      }
+    }
+  }
+}
+
+/*
+ * Calculate the shortest path tree for all nodes in this tree and
+ * return this result as a list of NodeList as in shortestPathTree.
+ * That is, result[0] will contain the shortest path map rooted at node 0,
+ * result[1] will be rooted at node 1, and so on.
+ */
+struct NodeTree *allShortestPathTrees(const struct NodeTree *tree)
+{
+  struct NodeTree *result = newNodeTree(tree->size);
+  qbase_t i;
+  for (i = 0; i < tree->size; ++i) {
+    shortestPathTree(i, tree, &result->nl[i]);
+  }
+  return result;
+}
+
+/*
+ * Finds the (shortest and only) path starting at a and going to b.
+ * Returns this as a list of the following form:
+ * a .. n1 .. n2 .. b
+ * or if a == b, then
+ *    a
+ */
+void findPath(struct NodeList *result, const struct FastTree *ft, qbase_t a, qbase_t b)
+{
+  const struct NodeList *nl = &ft->spm->nl[b];
+  result->size = 0;
+  while (a != b) {
+    push_back(result, a);
+    a = nl->n[a];
+  }
+  push_back(result, a);
+}
+
+/*
+ * Returns 1 iff the two paths a and b intersect.
+ */
+int pathsIntersect(const struct NodeList *a, const struct NodeList *b)
+{
+  int i, j;
+  for (i = 0; i < a->size; i++)
+    for (j = 0; j < b->size; j++)
+      if (a->n[i] == b->n[j])
+        return 1;
+  return 0;
+}
+
+int quartetCompatible(const struct Quartet* q, const struct FastTree *ft)
+{
+  struct NodeList pa, pb;
+  findPath(&pa, ft, q->q[0], q->q[1]);
+  findPath(&pb, ft, q->q[2], q->q[3]);
+  return !pathsIntersect(&pa,&pb);
+}
+
+weight_t calculateWeightedScore(const struct FastTree *ft, const struct QuartetList *ql)
+{
+  weight_t acc=0;
+  unsigned int i;
+  for (i = 0; i < ql->num; ++i) {
+    if (quartetCompatible(&ql->q[i], ft))
+      acc += ql->q[i].weight;
+  }
+  return acc;
+}
+
+void removeFromList(struct NodeList *nl, qbase_t me)
+{
+  int i;
+  int oldsize = nl->size;
+  nl->size = 0;
+  for (i = 0; i < oldsize; ++i) {
+    qbase_t cur = nl->n[i];
+    if (cur != me)
+      push_back(nl, cur);
+  }
+}
+
+void disconnectNodes(struct FastTree *ft, qbase_t a, qbase_t b)
+{
+  removeFromList(&ft->tree->nl[a], b);
+  removeFromList(&ft->tree->nl[b], a);
+}
+
+void connectNodes(struct FastTree *ft, qbase_t a, qbase_t b)
+{
+  push_back(&ft->tree->nl[a], b);
+  push_back(&ft->tree->nl[b], a);
+}
+
+void freeQuartetList(struct QuartetList *ql)
+{
+  // f7. f6. or f9. f8.
+  free(ql->q);
+  ql->q = NULL;
+  free(ql);
+}
+
+struct FastTree *newFastTree(int size)
+{
+  // m10.
+  struct FastTree *result = (struct FastTree *) calloc(sizeof(struct FastTree), 1);
+  result->spec = size;
+  result->score = 0;
+  result->tree = newNodeTree(size);
+  result->spm = NULL;
+  return result;
+}
+
+void freeFastTree(struct FastTree *ft)
+{
+  if (ft->tree) {
+    freeNodeTree(ft->tree);
+    ft->tree = NULL;
+  }
+  if (ft->spm) {
+    freeNodeTree(ft->spm);
+    ft->spm = NULL;
+  }
+  ft->spec = 0;
+  ft->score = 0;
+  // f10.
+  free(ft);
+}
+

data/ext/Quartet.h

@@ -0,0 +1,62 @@
+#ifndef __MQUARTET_H
+#define __MQUARTET_H
+
+#define MAXNODES 1024
+
+#include <sys/types.h>
+
+typedef unsigned char qbase_t;
+typedef double weight_t;
+typedef double dist_t;
+
+struct Quartet {
+  weight_t weight;
+  qbase_t q[4];
+};
+
+struct NodeList {
+  size_t size;
+  qbase_t n[MAXNODES];
+};
+
+struct NodeTree {
+  size_t size;
+  struct NodeList *nl;
+};
+
+struct DistMatrix {
+  size_t size;
+  double **vals;
+};
+
+struct QuartetList {
+  size_t num;
+  struct Quartet *q;
+};
+
+struct FastTree {
+  int spec;
+	weight_t score;
+  struct NodeTree *tree, *spm;
+};
+
+
+struct FastTree *newFastTree(int size);
+void freeFastTree(struct FastTree *ft);
+struct NodeList *newNodeList(int size);
+struct NodeTree *newNodeTree(int size);
+void freeNodeList(struct NodeList *nl);
+void freeNodeTree(struct NodeTree *nt);
+struct DistMatrix *newDistMatrix(int size);
+void freeDistMatrix(struct DistMatrix *dm);
+struct NodeTree *allShortestPathTrees(const struct NodeTree *tree);
+weight_t calculateWeightedScore(const struct FastTree *ft, const struct QuartetList *ql);
+struct FastTree *makeMutatedCopy(const struct FastTree *ft);
+void findPath(struct NodeList *result, const struct FastTree *ft, qbase_t a, qbase_t b);
+struct QuartetList *makeFullQuartetList(const struct DistMatrix *dm, weight_t *worst, weight_t *best);
+struct QuartetList *makeBestQuartetList(const struct DistMatrix *dm, weight_t *worst, weight_t *best);
+void freeQuartetList(struct QuartetList *ql);
+void push_back(struct NodeList *nl, qbase_t which);
+
+#endif
+