chrislo-sourceclassifier 0.2.0

data/sources/gcc/fasta.gcc-3.gcc

@@ -0,0 +1,145 @@
+/* The Computer Language Benchmarks Game
+ * http://shootout.alioth.debian.org/
+ * Contributed by Joern Inge Vestgaarden
+ * Modified by Jorge Peixoto de Morais Neto
+ * Modified by Ryan Flynn
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <err.h>
+
+#define WIDTH 60
+#define MIN(a,b) ((a) <= (b) ? (a) : (b))
+#define NELEMENTS(x) (sizeof (x) / sizeof ((x)[0]))
+
+typedef struct {
+    float p;
+    char c;
+} aminoacid_t;
+
+static inline float myrandom (float max) {
+    unsigned long const IM = 139968;
+    unsigned long const IA = 3877;
+    unsigned long const IC = 29573;
+    static unsigned long last = 42;
+    last = (last * IA + IC) % IM;
+    /*Integer to float conversions are faster if the integer is signed*/
+    return max * (long) last / IM;
+}
+
+static inline void accumulate_probabilities (aminoacid_t *genelist, size_t len) {
+    float cp = 0.0;
+    size_t i;
+    for (i = 0; i < len; i++) {
+        cp += genelist[i].p;
+        genelist[i].p = cp;
+    }
+}
+
+/* This function prints the characters of the string s. When it */
+/* reaches the end of the string, it goes back to the beginning */
+/* It stops when the total number of characters printed is count. */
+/* Between each WIDTH consecutive characters it prints a newline */
+/* This function assumes that WIDTH <= strlen (s) + 1 */
+static void repeat_fasta (char const *s, size_t count) {
+    size_t pos = 0;
+    size_t len = strlen (s);
+    char *s2 = malloc (len + WIDTH);
+    memcpy (s2, s, len);
+    memcpy (s2 + len, s, WIDTH);
+    do {
+     	size_t line = MIN(WIDTH, count);
+     	fwrite_unlocked (s2 + pos,1,line,stdout);
+     	putchar_unlocked ('\n');
+     	pos += line;
+     	if (pos >= len) pos -= len;
+     	count -= line;
+    } while (count);
+    free (s2);
+}
+
+/* This function takes a pointer to the first element of an array */
+/* Each element of the array is a struct with a character and */
+/* a float number p between 0 and 1. */
+/* The function generates a random float number r and */
+/* finds the first array element such that p >= r. */
+/* This is a weighted random selection. */
+/* The function then prints the character of the array element. */
+/* This is done count times. */
+/* Between each WIDTH consecutive characters, the function prints a newline */
+static void random_fasta (aminoacid_t const *genelist, size_t count) {
+    do {
+	size_t line = MIN(WIDTH, count);
+	size_t pos = 0;
+	char buf[WIDTH + 1];
+	do {
+	    float r = myrandom (1.0);
+	    size_t i = 0;
+	    while (genelist[i].p < r)
+		++i; /* Linear search */
+	    buf[pos++] = genelist[i].c;
+	} while (pos < line);
+	buf[line] = '\n';
+	fwrite_unlocked (buf, 1, line + 1, stdout);
+	count -= line;
+    } while (count);
+}
+
+int main (int argc, char **argv) {
+    static char OutBuf[128 * 1024];
+    size_t n;
+    if (argc > 1) {
+	char const *arg = argv[1];
+ 	char *tail;
+ 	n = strtoul (arg, &tail, 0);
+ 	if (tail == arg)
+	    errx (1, "Could not convert \"%s\" to an unsigned long integer", arg);
+    } else n = 1000;
+
+    static aminoacid_t 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' }};
+
+    static aminoacid_t homosapiens[] = {
+	{ 0.3029549426680, 'a' },
+	{ 0.1979883004921, 'c' },
+	{ 0.1975473066391, 'g' },
+	{ 0.3015094502008, 't' }};
+
+    accumulate_probabilities (iub, NELEMENTS(iub));
+    accumulate_probabilities (homosapiens, NELEMENTS(homosapiens));
+
+    static char const *const alu ="\
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG\
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA\
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT\
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA\
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG\
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC\
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA";
+
+    setvbuf(stdout, OutBuf, _IOFBF, sizeof OutBuf); /* buffer output */
+    fputs_unlocked (">ONE Homo sapiens alu\n", stdout);
+    repeat_fasta (alu, 2 * n);
+    fputs_unlocked (">TWO IUB ambiguity codes\n", stdout);
+    random_fasta (iub, 3 * n);
+    fputs_unlocked (">THREE Homo sapiens frequency\n", stdout);
+    random_fasta (homosapiens, 5 * n);
+    return 0;
+}
+

data/sources/gcc/fasta.gcc-4.gcc

@@ -0,0 +1,141 @@
+/* The Computer Language Benchmarks Game
+ * http://shootout.alioth.debian.org/
+ * Contributed by Joern Inge Vestgaarden
+ * Modified by Jorge Peixoto de Morais Neto
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <err.h>
+
+#define WIDTH 60
+#define MIN(a,b) ((a) <= (b) ? (a) : (b))
+#define NELEMENTS(x) (sizeof (x) / sizeof ((x)[0]))
+
+typedef struct {
+    float p;
+    char c;
+} aminoacid_t;
+
+static inline float myrandom (float max) { 
+    unsigned long const IM = 139968;
+    unsigned long const IA = 3877;
+    unsigned long const IC = 29573;
+    static unsigned long last = 42; 
+    last = (last * IA + IC) % IM; 
+    /*Integer to float conversions are faster if the integer is signed*/
+    return max * (long) last / IM; 
+} 
+
+static inline void accumulate_probabilities (aminoacid_t *genelist, size_t len) {
+    float cp = 0.0;
+    size_t i;
+    for (i = 0; i < len; i++) {
+        cp += genelist[i].p;
+        genelist[i].p = cp;
+    }
+}
+
+/* This function prints the characters of the string s. When it */
+/* reaches the end of the string, it goes back to the beginning */
+/* It stops when the total number of characters printed is count. */
+/* Between each WIDTH consecutive characters it prints a newline */
+/* This function assumes that WIDTH <= strlen (s) + 1 */
+static void repeat_fasta (char const *s, size_t count) {
+    size_t pos = 0;  
+    size_t len = strlen (s); 
+    char *s2 = malloc (len + WIDTH);
+    memcpy (s2, s, len); 
+    memcpy (s2 + len, s, WIDTH); 
+    do {   
+     	size_t line = MIN(WIDTH, count); 
+     	fwrite_unlocked (s2 + pos,1,line,stdout); 
+     	putchar_unlocked ('\n'); 
+     	pos += line; 
+     	if (pos >= len) pos -= len; 
+     	count -= line;  
+    } while (count); 
+    free (s2); 
+}
+
+/* This function takes a pointer to the first element of an array */
+/* Each element of the array is a struct with a character and */
+/* a float number p between 0 and 1. */
+/* The function generates a random float number r and */
+/* finds the first array element such that p >= r. */
+/* This is a weighted random selection. */
+/* The function then prints the character of the array element. */
+/* This is done count times. */
+/* Between each WIDTH consecutive characters, the function prints a newline */
+static void random_fasta (aminoacid_t const *genelist, size_t count) {
+    do {    
+	size_t line = MIN(WIDTH, count);    
+	size_t pos = 0;    
+	char buf[WIDTH + 1];    
+	do {    
+	    float r = myrandom (1.0);
+	    size_t i = 0;   
+	    while (genelist[i].p < r)    
+		++i; /* Linear search */    
+	    buf[pos++] = genelist[i].c;    
+	} while (pos < line);   
+	buf[line] = '\n';
+	fwrite_unlocked (buf, 1, line + 1, stdout);    
+	count -= line;    
+    } while (count);   
+}
+
+int main (int argc, char **argv) {
+    size_t n;
+    if (argc > 1) { 
+	char const *arg = argv[1];
+ 	char *tail; 
+ 	n = strtoul (arg, &tail, 0); 
+ 	if (tail == arg)  
+	    errx (1, "Could not convert \"%s\" to an unsigned long integer", arg); 
+    } else n = 1000;
+
+    static aminoacid_t 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' }};
+
+    static aminoacid_t homosapiens[] = {
+	{ 0.3029549426680, 'a' },
+	{ 0.1979883004921, 'c' },
+	{ 0.1975473066391, 'g' },
+	{ 0.3015094502008, 't' }};
+
+    accumulate_probabilities (iub, NELEMENTS(iub)); 
+    accumulate_probabilities (homosapiens, NELEMENTS(homosapiens));
+
+    static char const *const alu ="\
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG\
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA\
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT\
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA\
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG\
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC\
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA";
+
+    fputs_unlocked (">ONE Homo sapiens alu\n", stdout);
+    repeat_fasta (alu, 2 * n);
+    fputs_unlocked (">TWO IUB ambiguity codes\n", stdout);
+    random_fasta (iub, 3 * n);
+    fputs_unlocked (">THREE Homo sapiens frequency\n", stdout);
+    random_fasta (homosapiens, 5 * n);
+    return 0;
+}

data/sources/gcc/fibo.gcc

@@ -0,0 +1,20 @@
+/* -*- mode: c -*-
+ * $Id: fibo.gcc,v 1.6 2005-04-25 19:01:38 igouy-guest Exp $
+ * http://shootout.alioth.debian.org/
+ * Revised with register allocation by David Bronaugh
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static unsigned long
+fib(unsigned long n) {
+    return( (n < 2) ? 1 : (fib(n-2) + fib(n-1)) );
+}
+
+int
+main(int argc, char *argv[]) {
+    int N = ((argc == 2) ? atoi(argv[1]) : 1);
+    printf("%ld\n", fib(N));
+    return(0);
+}

data/sources/gcc/harmonic.gcc

@@ -0,0 +1,22 @@
+/* The Great Computer Language Shootout
+   http://shootout.alioth.debian.org/
+
+   contributed by Greg Buchholz 
+   Optimized by Paul Hsieh
+   compile:  gcc -O2 -o harmonic harmonic.c
+*/
+#include<stdio.h>
+#include<stdlib.h>
+
+int main (int argc, char **argv)
+{
+    double i=1, sum=0;
+    int n;
+
+    for(n = atoi(argv[1]); n > 0; n--, i++)
+        sum += 1/i;
+
+    printf("%.9f\n", sum);
+    return 0;
+}
+

data/sources/gcc/hash.gcc

@@ -0,0 +1,31 @@
+/* -*- mode: c -*-
+ * $Id: hash.gcc,v 1.1.1.1 2004-05-19 18:09:55 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "../../Include/simple_hash.h"
+
+int main(int argc, char *argv[]) {
+    int i, c=0, n = ((argc == 2) ? atoi(argv[1]) : 1);
+    char buf[32];
+	
+    struct ht_ht *ht = ht_create(n);
+    
+    for (i=1; i<=n; i++) {
+	sprintf(buf, "%x", i);
+	(ht_find_new(ht, buf))->val = i;
+    }
+
+    for (i=n; i>0; i--) {
+	sprintf(buf, "%d", i);
+	if (ht_find(ht, buf)) c++;
+    }
+
+    ht_destroy(ht);
+
+    printf("%d\n", c);
+    return(0);
+}

data/sources/gcc/hash2.gcc

@@ -0,0 +1,38 @@
+/* -*- mode: c -*-
+ * $Id: hash2.gcc,v 1.1.1.1 2004-05-19 18:10:02 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "../../Include/simple_hash.h"
+
+int main(int argc, char *argv[]) {
+    int i, n = ((argc == 2) ? atoi(argv[1]) : 1);
+    char buf[32];
+    struct ht_ht *ht1 = ht_create(10000);
+    struct ht_ht *ht2 = ht_create(10000);
+    struct ht_node *node;
+
+    for (i=0; i<=9999; ++i) {
+	sprintf(buf, "foo_%d", i);
+	ht_find_new(ht1, buf)->val = i;
+    }
+
+    for (i=0; i<n; ++i) {
+	for (node=ht_first(ht1); node; node=ht_next(ht1)) {
+	    ht_find_new(ht2, node->key)->val += node->val;
+	}
+    }
+
+    printf("%d %d %d %d\n",
+	   (ht_find(ht1, "foo_1"))->val,
+	   (ht_find(ht1, "foo_9999"))->val,
+	   (ht_find(ht2, "foo_1"))->val,
+	   (ht_find(ht2, "foo_9999"))->val);
+
+    ht_destroy(ht1);
+    ht_destroy(ht2);
+    return(0);
+}

data/sources/gcc/heapsort.gcc

@@ -0,0 +1,72 @@
+/* -*- mode: c -*-
+ * $Id: heapsort.gcc,v 1.1.1.1 2004-05-19 18:10:08 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.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 );
+}
+
+void
+heapsort(int n, double *ra) {
+    int i, j;
+    int ir = n;
+    int l = (n >> 1) + 1;
+    double rra;
+
+    for (;;) {
+	if (l > 1) {
+	    rra = ra[--l];
+	} else {
+	    rra = ra[ir];
+	    ra[ir] = ra[1];
+	    if (--ir == 1) {
+		ra[1] = rra;
+		return;
+	    }
+	}
+	i = l;
+	j = l << 1;
+	while (j <= ir) {
+	    if (j < ir && ra[j] < ra[j+1]) { ++j; }
+	    if (rra < ra[j]) {
+		ra[i] = ra[j];
+		j += (i = j);
+	    } else {
+		j = ir + 1;
+	    }
+	}
+	ra[i] = rra;
+    }
+}
+
+int
+main(int argc, char *argv[]) {
+    int N = ((argc == 2) ? atoi(argv[1]) : 1);
+    double *ary;
+    int i;
+    
+    /* create an array of N random doubles */
+    ary = (double *)malloc((N+1) * sizeof(double));
+    for (i=1; i<=N; i++) {
+	ary[i] = gen_random(1);
+    }
+
+    heapsort(N, ary);
+
+    printf("%.10f\n", ary[N]);
+
+    free(ary);
+    return(0);
+}
+