chrislo-sourceclassifier 0.2.0

data/sources/gcc/except.gcc

@@ -0,0 +1,52 @@
+/* -*- mode: c -*-
+ * $Id: except.gcc,v 1.1.1.1 2004-05-19 18:09:42 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <setjmp.h>
+
+int HI = 0, LO = 0;
+
+static jmp_buf Hi_exception;
+static jmp_buf Lo_exception;
+
+void blowup (int n) {
+    if (n & 1) {
+	longjmp(Lo_exception, 1);
+    } else {
+	longjmp(Hi_exception, 1);
+    }
+}
+
+void lo_function (volatile int n) {
+    if (setjmp(Lo_exception) != 0) {
+	LO++;
+    } else {
+	blowup(n);
+    }
+}
+
+void hi_function (volatile int n) {
+    if (setjmp(Hi_exception) != 0) {
+	HI++;
+    } else {
+	lo_function(n);
+    }
+}
+
+void some_function (int n) {
+    hi_function(n);
+}
+
+int
+main(int argc, char *argv[]) {
+    int volatile N = ((argc == 2) ? atoi(argv[1]) : 1);
+
+    while (N) {
+	some_function(N--);
+    }
+    printf("Exceptions: HI=%d / LO=%d\n", HI, LO);
+    return(0);
+}

data/sources/gcc/fannkuch.gcc

@@ -0,0 +1,105 @@
+/*
+ * The Computer Lannguage Shootout
+ * http://shootout.alioth.debian.org/
+ * Contributed by Heiner Marxen
+ *
+ * "fannkuch"	for C gcc
+ *
+ * $Id: fannkuch.gcc,v 1.5 2005-12-04 23:58:38 igouy-guest Exp $
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define Int	int
+#define Aint	int
+
+    static long
+fannkuch( int n )
+{
+    Aint*	perm;
+    Aint*	perm1;
+    Aint*	count;
+    long	flips;
+    long	flipsMax;
+    Int		r;
+    Int		i;
+    Int		k;
+    Int		didpr;
+    const Int	n1	= n - 1;
+
+    if( n < 1 ) return 0;
+
+    perm  = calloc(n, sizeof(*perm ));
+    perm1 = calloc(n, sizeof(*perm1));
+    count = calloc(n, sizeof(*count));
+
+    for( i=0 ; i<n ; ++i ) perm1[i] = i;	/* initial (trivial) permu */
+
+    r = n; didpr = 0; flipsMax = 0;
+    for(;;) {
+	if( didpr < 30 ) {
+	    for( i=0 ; i<n ; ++i ) printf("%d", (int)(1+perm1[i]));
+	    printf("\n");
+	    ++didpr;
+	}
+	for( ; r!=1 ; --r ) {
+	    count[r-1] = r;
+	}
+
+#define XCH(x,y)	{ Aint t_mp; t_mp=(x); (x)=(y); (y)=t_mp; }
+
+	if( ! (perm1[0]==0 || perm1[n1]==n1) ) {
+	    flips = 0;
+	    for( i=1 ; i<n ; ++i ) {	/* perm = perm1 */
+		perm[i] = perm1[i];
+	    }
+	    k = perm1[0];		/* cache perm[0] in k */
+	    do {			/* k!=0 ==> k>0 */
+		Int	j;
+		for( i=1, j=k-1 ; i<j ; ++i, --j ) {
+		    XCH(perm[i], perm[j])
+		}
+		++flips;
+		/*
+		 * Now exchange k (caching perm[0]) and perm[k]... with care!
+		 * XCH(k, perm[k]) does NOT work!
+		 */
+		j=perm[k]; perm[k]=k ; k=j;
+	    }while( k );
+	    if( flipsMax < flips ) {
+		flipsMax = flips;
+	    }
+	}
+
+	for(;;) {
+	    if( r == n ) {
+		return flipsMax;
+	    }
+	    /* rotate down perm[0..r] by one */
+	    {
+		Int	perm0 = perm1[0];
+		i = 0;
+		while( i < r ) {
+		    k = i+1;
+		    perm1[i] = perm1[k];
+		    i = k;
+		}
+		perm1[r] = perm0;
+	    }
+	    if( (count[r] -= 1) > 0 ) {
+		break;
+	    }
+	    ++r;
+	}
+    }
+}
+
+    int
+main( int argc, char* argv[] )
+{
+    int		n = (argc>1) ? atoi(argv[1]) : 0;
+
+    printf("Pfannkuchen(%d) = %ld\n", n, fannkuch(n));
+    return 0;
+}

data/sources/gcc/fannkuch.gcc-2.gcc

@@ -0,0 +1,94 @@
+/**
+ * The Computer Language Benchmarks game
+ * http://shootout.alioth.debian.org/
+ *
+ * Contributed by Rodney Drenth
+ *
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void PrintPerm( int *perm, int n)
+{
+   while(n-- >0) printf("%d", 1+*perm++);
+   printf("\n");
+}
+#define XCNG(a,b,t) {t=a;a=b;b=t;}
+
+int fannkuch( int n )
+{
+   int      *count, *perm, *perm1, *perm2, *p1, *pA;
+   int      **prmts;
+   int      flips, maxFlips;
+   int      r, i, k, m, nx;
+   int      check = 30;
+
+    if (n <= 1)
+      return 0;
+
+   prmts = calloc( n, sizeof( int *));
+   perm1 = pA = calloc( (n+4)*n, sizeof(int));
+   perm2 = perm1 + n;
+   count = perm1 + 2*n;
+   perm  = perm1 + 3*n;
+   p1 = perm1 + 4*n;
+   for (r=0; r<n; r++) {
+      prmts[r] = perm1 + (4+r)*n;
+      p1[r] = perm1[r] = r;
+      count[r] = r+1;
+   }
+   for (nx=1; nx<n; nx++) {   // compute permutation operators
+      int *p2 = prmts[nx];
+      for (i=0; i<nx; i++) p2[i] = p1[i+1];
+      p2[i++] = p1[0];
+      for ( ; i<n; i++) p2[i] = p1[i];
+      p1=p2;
+   }
+
+   m = n-1;
+   maxFlips = 1;
+   r = 0;
+   while (1) {
+      if (check>0 ) {
+         PrintPerm( perm1, n);
+         check--;
+      }
+      k = perm1[0];
+      if ( perm1[k]!=0 && (perm1[m]!= m)) {
+         for (i=n; --i>0; ) 
+            perm[i] = perm1[i];   
+         perm[0] = k;
+         for (flips=0; k; flips++) { 
+            int l, *pk;
+            l = (k-1)/2;
+            for( pk = perm+k; l>=0; --l) {
+               XCNG(*(pk-l), *(perm+l), k);
+            };
+            // Note: final exchange leaves perm[0] in k
+          }
+         if (maxFlips < flips) maxFlips = flips;
+      }
+      r = 1;
+      while (--count[r] == 0) {
+         r = count[r] = r+1;
+         if (r== n) {
+            free(prmts); free(pA);
+            return maxFlips;
+         }
+      }
+      // generate permutation nx=5 first time.
+      XCNG(perm1,perm2,p1);
+      if (r>1) nx = r+1;
+      p1 = prmts[r]; 
+      for (i=0; i< nx; i++)
+         perm1[i] = perm2[p1[i]];
+   }
+}
+
+int main( int argc, char* argv[] )
+{
+    int      n = (argc>1) ? atoi(argv[1]) : 1;
+    printf("Pfannkuchen(%d) = %d\n", n, fannkuch(n));
+}

data/sources/gcc/fasta.gcc

@@ -0,0 +1,158 @@
+/* -*- mode: c -*-
+ * $Id: fasta.gcc,v 1.1 2005-03-19 07:50:09 bfulgham Exp $
+ * http://shootout.alioth.debian.org/
+ *
+ * by Paul Hsieh
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define IM 139968
+#define IA   3877
+#define IC  29573
+
+double gen_random (double max) {
+    static long last = 42;
+    return max * (last = (last * IA + IC) % IM) / IM;
+}
+
+struct aminoacids {
+    char c;
+    double p;
+};
+
+/* Weighted selection from alphabet */
+
+void makeCumulative (struct aminoacids * genelist, int count) {
+    double cp = 0.0;
+    int i;
+
+    for (i=0; i < count; i++) {
+        cp += genelist[i].p;
+        genelist[i].p = cp;
+    }
+}
+
+char selectRandom (const struct aminoacids * genelist, int count) {
+    double r = gen_random (1);
+    int i, lo, hi;
+
+    if (r < genelist[0].p) return genelist[0].c;
+
+    lo = 0;
+    hi = count-1;
+
+    while (hi > lo+1) {
+        i = (hi + lo) / 2;
+        if (r < genelist[i].p) hi = i; else lo = i;
+    }
+    return genelist[hi].c;
+}
+
+/* Generate and write FASTA format */
+
+#define LINE_LENGTH (60)
+
+void makeRandomFasta (const char * id, const char * desc, const struct 
+aminoacids * genelist, int count, int n) {
+   int todo = n;
+   int i, m;
+
+   printf (">%s %s\n", id, desc);
+
+   for (; todo > 0; todo -= LINE_LENGTH) {
+       char pick[LINE_LENGTH+1];
+       if (todo < LINE_LENGTH) m = todo; else m = LINE_LENGTH;
+       for (i=0; i < m; i++) pick[i] = selectRandom (genelist, count);
+       pick[m] = '\0';
+       puts (pick);
+   }
+}
+
+void makeRepeatFasta (const char * id, const char * desc, const char * 
+s, int n) {
+   char * ss;
+   int todo = n, k = 0, kn = strlen (s);
+   int m;
+
+   ss = (char *) malloc (kn + 1);
+   memcpy (ss, s, kn+1);
+
+   printf (">%s %s\n", id, desc);
+
+   for (; todo > 0; todo -= LINE_LENGTH) {
+       if (todo < LINE_LENGTH) m = todo; else m = LINE_LENGTH;
+
+       while (m >= kn - k) {
+           printf ("%s", s+k);
+           m -= kn - k;
+           k = 0;
+       }
+
+       ss[k + m] = '\0';
+       puts (ss+k);
+       ss[k + m] = s[m+k];
+       k += m;
+   }
+
+   free (ss);
+}
+
+/* Main -- define alphabets, make 3 fragments */
+
+struct aminoacids iub[] = {
+    { 'a', 0.27 },
+    { 'c', 0.12 },
+    { 'g', 0.12 },
+    { 't', 0.27 },
+
+    { 'B', 0.02 },
+    { 'D', 0.02 },
+    { 'H', 0.02 },
+    { 'K', 0.02 },
+    { 'M', 0.02 },
+    { 'N', 0.02 },
+    { 'R', 0.02 },
+    { 'S', 0.02 },
+    { 'V', 0.02 },
+    { 'W', 0.02 },
+    { 'Y', 0.02 }
+};
+
+#define IUB_LEN (sizeof (iub) / sizeof (struct aminoacids))
+
+struct aminoacids homosapiens[] = {
+    { 'a', 0.3029549426680 },
+    { 'c', 0.1979883004921 },
+    { 'g', 0.1975473066391 },
+    { 't', 0.3015094502008 },
+};
+
+#define HOMOSAPIENS_LEN (sizeof (homosapiens) / sizeof (struct aminoacids))
+
+char * alu =
+   "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" \
+   "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA" \
+   "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT" \
+   "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA" \
+   "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG" \
+   "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC" \
+   "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA";
+
+int main (int argc, char * argv[]) {
+    int n = 1000;
+
+    if (argc > 1) sscanf (argv[1], "%d", &n);
+
+    makeCumulative (iub, IUB_LEN);
+    makeCumulative (homosapiens, HOMOSAPIENS_LEN);
+
+    makeRepeatFasta ("ONE", "Homo sapiens alu", alu, n*2);
+    makeRandomFasta ("TWO", "IUB ambiguity codes", iub, IUB_LEN, n*3);
+    makeRandomFasta ("THREE", "Homo sapiens frequency", homosapiens, 
+HOMOSAPIENS_LEN, n*5);
+
+    return 0;
+}
+

data/sources/gcc/fasta.gcc-2.gcc

@@ -0,0 +1,132 @@
+/* The Computer Language Shootout
+ * http://shootout.alioth.debian.org/
+ * contributed by Joern Inge Vestgaarden
+ * Compile with gcc -O3 -fomit-frame-pointer -march=pentium4 -mfpmath=sse -msse2 -o fasta fasta.c
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MIN(a,b) ((a) <= (b) ? (a) : (b))
+#define LINE_LEN 60
+
+#define IM 139968
+#define IA   3877
+#define IC  29573
+int global_last = 42;
+#define gen_random(max) (max*((global_last = (global_last * IA + IC) % IM) / ((float)(IM))))
+
+struct aminoacids {
+  float p;
+  char c;
+};
+
+void make_cumulative (struct aminoacids * genelist, int count) {
+    float cp = 0.0;
+    int i;
+    for (i=0; i < count; i++) {
+        cp += genelist[i].p;
+        genelist[i].p = cp;
+    }
+}
+
+void repeat_fasta (const char *s, int n) {
+  int len = strlen(s);
+  int pos = 0;
+  while (n > 0) {
+    const int line = MIN(LINE_LEN, n);
+    const int left = len-pos; 
+    n -= line;
+    if (left >= line) {     /* Line not broken */
+      fwrite(s+pos,1,line,stdout);
+      putc('\n', stdout);
+      pos += line;
+    } else {                /* Line broken */
+      fwrite(s+pos,1,left,stdout);
+      pos = 0;
+      fwrite(s,1,line-left,stdout);
+      pos += line - left;
+      putc('\n', stdout);
+    }
+  }    
+}
+
+void random_fasta (struct aminoacids * genelist, int n) {
+  char buf[LINE_LEN+1];
+  char *s = NULL;
+  struct aminoacids *a = genelist;
+  float r;
+  while (n > 0) {
+    const int line = MIN(LINE_LEN, n);
+    const char *end = (char *)buf + line;
+    n -= line;
+    s = buf;
+    while (s < end) {
+      r = gen_random(1.0);
+      a = genelist;
+      while (*((float *)a) < r) ++a; /* Linear search */
+      *s++ = a->c;
+    }
+    *s = '\n';
+    fwrite(buf, 1, line+1, stdout);
+  }
+}
+
+
+/* Main -- define alphabets, make 3 fragments */
+
+static struct aminoacids iub[] = {
+    { 0.27, 'a' },
+    { 0.12, 'c' },
+    { 0.12, 'g' },
+    { 0.27, 't' },
+    { 0.02, 'B' },
+    { 0.02, 'D' },
+    { 0.02, 'H' },
+    { 0.02, 'K' },
+    { 0.02, 'M' },
+    { 0.02, 'N' },
+    { 0.02, 'R' },
+    { 0.02, 'S' },
+    { 0.02, 'V' },
+    { 0.02, 'W' },
+    { 0.02, 'Y' }
+};
+
+#define IUB_LEN (sizeof (iub) / sizeof (struct aminoacids))
+
+static struct aminoacids homosapiens[] = {
+    { 0.3029549426680, 'a' },
+    { 0.1979883004921, 'c' },
+    { 0.1975473066391, 'g' },
+    { 0.3015094502008, 't' },
+};
+
+#define HOMOSAPIENS_LEN (sizeof (homosapiens) / sizeof (struct aminoacids))
+
+static char * alu =
+   "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" \
+   "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA" \
+   "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT" \
+   "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA" \
+   "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG" \
+   "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC" \
+   "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA";
+
+int main (int argc, char * argv[]) {
+    int n = 1000;
+    if (argc > 1) sscanf (argv[1], "%d", &n);
+    make_cumulative (iub, IUB_LEN);
+    make_cumulative (homosapiens, HOMOSAPIENS_LEN);
+
+    printf (">ONE Homo sapiens alu\n");
+    repeat_fasta ( alu, n*2);
+    printf (">TWO IUB ambiguity codes\n");    
+    random_fasta ( iub,   n*3);
+    printf (">THREE Homo sapiens frequency\n");
+    random_fasta ( homosapiens,  n*5);
+
+    return 0;
+}
+