chrislo-sourceclassifier 0.2.0

data/sources/gcc/nestedloop.gcc

@@ -0,0 +1,25 @@
+/* -*- mode: c -*-
+ * $Id: nestedloop.gcc,v 1.1.1.1 2004-05-19 18:10:56 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int
+main(int argc, char *argv[]) {
+    int n = ((argc == 2) ? atoi(argv[1]) : 1);
+    int a, b, c, d, e, f, x=0;
+	
+    for (a=0; a<n; a++)
+	for (b=0; b<n; b++)
+	    for (c=0; c<n; c++)
+		for (d=0; d<n; d++)
+		    for (e=0; e<n; e++)
+			for (f=0; f<n; f++)
+			    x++;
+
+    printf("%d\n", x);
+    return(0);
+}

data/sources/gcc/nsieve.gcc

@@ -0,0 +1,35 @@
+// The Computer Language Shootout
+// http://shootout.alioth.debian.org/
+// Precedent C entry modified by bearophile for speed and size, 31 Jan 2006
+// Compile with:  -O3 -s -std=c99 -fomit-frame-pointer
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef unsigned char boolean;
+
+
+static void nsieve(int m) {
+    unsigned int count = 0, i, j;
+    boolean * flags = (boolean *) malloc(m * sizeof(boolean));
+    memset(flags, 1, m);
+
+    for (i = 2; i < m; ++i)
+        if (flags[i]) {
+            ++count;
+            for (j = i << 1; j < m; j += i)
+//                if (flags[j]) 
+                   flags[j] = 0;
+    }
+
+    free(flags);
+    printf("Primes up to %8u %8u\n", m, count);
+}
+
+int main(int argc, char * argv[]) {
+    int m = atoi(argv[1]);
+    for (int i = 0; i < 3; i++)
+        nsieve(10000 << (m-i));
+    return 0;
+}

data/sources/gcc/nsievebits.gcc-2.gcc

@@ -0,0 +1,37 @@
+/*
+** The Great Computer Language Shootout
+** http://shootout.alioth.debian.org/
+** contributed by Mike Pall
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef unsigned int bits;
+#define BBITS		(sizeof(bits) * 8)
+#define BSIZE(x)	(((x) / 8) + sizeof(bits))
+#define BMASK(x)	(1 << ((x) % BBITS))
+#define BTEST(p, x)	((p)[(x) / BBITS] & BMASK(x))
+#define BFLIP(p, x)	(p)[(x) / BBITS] ^= BMASK(x)
+
+int main(int argc, char **argv)
+{
+  unsigned int m, sz = 10000 << (argc > 1 ? atoi(argv[1]) : 1);
+  bits *primes = (bits *)malloc(BSIZE(sz));
+  if (!primes) return 1;
+  for (m = 0; m <= 2; m++) {
+    unsigned int i, j, count = 0, n = sz >> m;
+    memset(primes, 0xff, BSIZE(n));
+    for (i = 2; i <= n; i++)
+      if (BTEST(primes, i)) {
+	count++;
+	for (j = i + i; j <= n; j += i)
+	  if (BTEST(primes, j)) BFLIP(primes, j);
+      }
+    printf("Primes up to %8d %8d\n", n, count);
+  }
+  free(primes);
+  return 0;
+}
+

data/sources/gcc/nsievebits.gcc-3.gcc

@@ -0,0 +1,53 @@
+// The Computer Language Shootout
+// http://shootout.alioth.debian.org/
+// Precedent C entry modified by bearophile for speed and size, 31 Jan 2006
+// Modified to use bits to hold state by mukund
+// Compile with:  gcc -pipe -Wall -O3 -funroll-all-loops -march=athlon64 -m3dnow nsieve.c -o nsieve
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define INDEX_INT(i) ((i) >> 5)
+#define INDEX_BIT(i) (1 << ((i) & 0x1f))
+#define INDEX_BITMASK(i) (~INDEX_BIT(i))
+
+int
+main (int argc, char *argv[])
+{
+  int n = atoi (argv[1]);
+  unsigned int count1 = 0, count2 = 0, count4 = 0;
+  unsigned int i, j, m, m2;
+  uint32_t *flags;
+
+  m = 10000 << n;
+
+  flags = (uint32_t *) malloc ((m / sizeof (uint32_t)) + 1);
+  memset (flags, 0xff, (m / sizeof (uint32_t)) + 1);
+
+  for (i = 2; i < m; ++i)
+    {
+      if (flags[INDEX_INT (i)] & INDEX_BIT (i))
+        {
+          for (j = i * 2; j <= m; j += i)
+            flags[INDEX_INT (j)] &= INDEX_BITMASK (j);
+
+          ++count1;
+          m2 = m >> 1;
+          if (i < m2)
+            ++count2;
+          m2 = m2 >> 1;
+          if (i < m2)
+            ++count4;
+        }
+    }
+
+  printf ("Primes up to %8u %8u\n", m, count1);
+  printf ("Primes up to %8u %8u\n", m / 2, count2);
+  printf ("Primes up to %8u %8u\n", m / 4, count4);
+
+  free (flags);
+
+  return 0;
+}

data/sources/gcc/objinst.gcc

@@ -0,0 +1,95 @@
+/* -*- mode: c -*-
+ * $Id: objinst.gcc,v 1.1.1.1 2004-05-19 18:11:02 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+enum {false, true};
+
+#define TOGGLE \
+    char state; \
+    char (*value)(struct Toggle *); \
+    struct Toggle *(*activate)(struct Toggle *)
+
+#define DESTROY  free
+
+typedef struct Toggle {
+    TOGGLE;
+} Toggle;
+
+char toggle_value(Toggle *this) {
+    return(this->state);
+}
+Toggle *toggle_activate(Toggle *this) {
+    this->state = !this->state;
+    return(this);
+}
+Toggle *init_Toggle(Toggle *this, char start_state) {
+    this->state = start_state;
+    this->value = toggle_value;
+    this->activate = toggle_activate;
+    return(this);
+}
+Toggle *new_Toggle(char start_state) {
+    Toggle *this = (Toggle *)malloc(sizeof(Toggle));
+    return(init_Toggle(this, start_state));
+}
+
+
+typedef struct NthToggle {
+    TOGGLE;
+    int count_max;
+    int counter;
+} NthToggle;
+
+NthToggle *nth_toggle_activate(NthToggle *this) {
+    if (++this->counter >= this->count_max) {
+	this->state = !this->state;
+	this->counter = 0;
+    }
+    return(this);
+}
+NthToggle *init_NthToggle(NthToggle *this, int max_count) {
+    this->count_max = max_count;
+    this->counter = 0;
+    this->activate = (Toggle *(*)(Toggle *))nth_toggle_activate;
+    return(this);
+}
+NthToggle *new_NthToggle(char start_state, int max_count) {
+    NthToggle *this = (NthToggle *)malloc(sizeof(NthToggle));
+    this = (NthToggle *)init_Toggle((Toggle *)this, start_state);
+    return(init_NthToggle(this, max_count));
+}
+
+
+int main(int argc, char *argv[]) {
+    int i, n = ((argc == 2) ? atoi(argv[1]) : 1);
+    Toggle *tog;
+    NthToggle *ntog;
+
+    tog = new_Toggle(true);
+    for (i=0; i<5; i++) {
+	fputs((tog->activate(tog)->value(tog)) ? "true\n" : "false\n", stdout);
+    }
+    DESTROY(tog);
+    for (i=0; i<n; i++) {
+	tog = new_Toggle(true);
+	DESTROY(tog);
+    }
+    
+    fputs("\n", stdout);
+
+    ntog = new_NthToggle(true, 3);
+    for (i=0; i<8; i++) {
+	fputs((ntog->activate(ntog)->value(ntog)) ? "true\n" : "false\n", stdout);
+    }
+    DESTROY(ntog);
+    for (i=0; i<n; i++) {
+	ntog = new_NthToggle(true, 3);
+	DESTROY(ntog);
+    }
+    return 0;
+}

data/sources/gcc/partialsums.gcc

@@ -0,0 +1,86 @@
+/*
+** The Great Computer Language Shootout
+** http://shootout.alioth.debian.org/
+** contributed by Mike Pall
+**
+** compile with:
+**   gcc -O3 -fomit-frame-pointer -ffast-math -o partialsums partialsums.c -lm
+**   Adding -march=<yourcpu> may help, too.
+**   On a P4/K8 or later try adding: --march=<yourcpu> -mfpmath=sse -msse2 
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+int main(int argc, char **argv)
+{
+  int k, n = atoi(argv[1]);
+  double sum;
+
+/*
+** Yes, I tried using a double as a primary or secondary loop variable.
+** But the x86 ABI requires a cleared x87 FPU stack before every call
+** (e.g. to sin()) which nullifies any performance gains.
+**
+** Combining all loops does not pay off because the x87 FPU has to shuffle
+** stack slots and/or runs out of registers. This may not be entirely true
+** for SSE2 with fully inlined FPU code (-ffast-math required). Dito for
+** other CPUs with a register-based FPU and a sane FP ABI.
+**
+** Auto vectorization may be a bit easier with separate loops, too.
+*/
+#define kd ((double)k)
+
+  sum = 0.0;
+  for (k = 0; k <= n; k++) {  /* pow(2.0/3.0, kd) inlined */
+    double x = 1.0, q = 2.0/3.0;
+    int j = k;
+    for (;;) { if (j & 1) x *= q; if ((j >>= 1) == 0) break; q = q*q; }
+    sum += x;
+  }
+  printf("%.9f\t(2/3)^k\n", sum);
+
+  sum = 0.0;
+  for (k = 1 ; k <= n; k++) sum += 1/sqrt(kd);  /* aka pow(kd, -0.5) */
+  printf("%.9f\tk^-0.5\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n; k++) sum += 1.0/(kd*(kd+1.0));
+  printf("%.9f\t1/k(k+1)\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n; k++) {
+    double sk = sin(kd);
+    sum += 1.0/(kd*kd*kd*sk*sk);
+  }
+  printf("%.9f\tFlint Hills\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n; k++) {
+    double ck = cos(kd);
+    sum += 1.0/((kd*kd)*kd*ck*ck);
+  }
+  printf("%.9f\tCookson Hills\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n; k++) sum += 1.0/kd;
+  printf("%.9f\tHarmonic\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n; k++) sum += 1.0/(kd*kd);
+  printf("%.9f\tRiemann Zeta\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n-1; k += 2) sum += 1.0/kd;
+  for (k = 2; k <= n; k += 2) sum -= 1.0/kd;
+  printf("%.9f\tAlternating Harmonic\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= 2*n-1; k += 4) sum += 1.0/kd;
+  for (k = 3; k <= 2*n; k += 4) sum -= 1.0/kd;
+  printf("%.9f\tGregory\n", sum);
+
+  return 0;
+}
+

data/sources/gcc/partialsums.gcc-3.gcc

@@ -0,0 +1,81 @@
+/*
+** The Computer Language Shootout
+** http://shootout.alioth.debian.org/
+** contributed by Mike Pall
+** de-optimized by Isaac Gouy
+**
+** compile with:
+**   gcc -O3 -fomit-frame-pointer -ffast-math -o partialsums partialsums.c -lm
+**   Adding -march=<yourcpu> may help, too.
+**   On a P4/K8 or later try adding: --march=<yourcpu> -mfpmath=sse -msse2 
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+int main(int argc, char **argv)
+{
+  int k, n = atoi(argv[1]);
+  double sum, a;
+
+/*
+** Yes, I (Mike Pall) tried using a double as a primary or secondary loop variable.
+** But the x86 ABI requires a cleared x87 FPU stack before every call
+** (e.g. to sin()) which nullifies any performance gains.
+**
+** Combining all loops does not pay off because the x87 FPU has to shuffle
+** stack slots and/or runs out of registers. This may not be entirely true
+** for SSE2 with fully inlined FPU code (-ffast-math required). Dito for
+** other CPUs with a register-based FPU and a sane FP ABI.
+**
+** Auto vectorization may be a bit easier with separate loops, too.
+*/
+
+#define kd ((double)k)
+
+  sum = 0.0;
+  for (k = 0; k <= n; k++) sum += pow(2.0/3.0, kd);
+  printf("%.9f\t(2/3)^k\n", sum);
+
+  sum = 0.0;
+  for (k = 1 ; k <= n; k++) sum += 1/sqrt(kd);  /* aka pow(kd, -0.5) */
+  printf("%.9f\tk^-0.5\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n; k++) sum += 1.0/(kd*(kd+1.0));
+  printf("%.9f\t1/k(k+1)\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n; k++) {
+    double sk = sin(kd);
+    sum += 1.0/(kd*kd*kd*sk*sk);
+  }
+  printf("%.9f\tFlint Hills\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n; k++) {
+    double ck = cos(kd);
+    sum += 1.0/(kd*kd*kd*ck*ck);
+  }
+  printf("%.9f\tCookson Hills\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n; k++) sum += 1.0/kd;
+  printf("%.9f\tHarmonic\n", sum);
+
+  sum = 0.0;
+  for (k = 1; k <= n; k++) sum += 1.0/(kd*kd);
+  printf("%.9f\tRiemann Zeta\n", sum);
+
+  sum = 0.0; a = -1.0;
+  for (k = 1; k <= n; k++) sum += (a = -a)/kd;
+  printf("%.9f\tAlternating Harmonic\n", sum);
+
+  sum = 0.0;  a = -1.0;
+  for (k = 1; k <= n; k++) sum += (a = -a)/(2.0*kd - 1.0);
+  printf("%.9f\tGregory\n", sum);
+
+  return 0;
+}
+

data/sources/gcc/partialsums.gcc-4.gcc

@@ -0,0 +1,68 @@
+//  The Computer Language Shootout
+//  http://shootout.alioth.debian.org/
+//  contributed by Greg Buchholz
+//  
+//  compile with:  -O3 -msse2 -lm
+
+#include<math.h>
+#include<stdio.h>
+
+typedef double v2df __attribute__ ((vector_size (16)));
+
+v2df make_vec(double a, double b)
+{
+    v2df v;
+    double *tmp;
+    tmp = (double *)&v; *(tmp) = a; *(tmp+1) = b;
+    return v;
+}
+
+double sum_vec(v2df x)
+{
+    double *tmp = (double *)&x; 
+    return *(tmp) + *(tmp+1);
+}
+
+int main(int argc, char* argv[])
+{
+    double  twoThrd = 0, sqrts = 0, Flint = 0, Cookson = 0;
+    v2df    Harmonic, zeta, poly, alt, Gregory;
+    v2df    zero, one, two, init, m_one, kv, av;
+    
+    double  k, k3, s, c;
+    int n;  n = atoi(argv[1]);
+
+    zero  = make_vec( 0.0,  0.0);  one   = make_vec( 1.0,  1.0);
+    two   = make_vec( 2.0,  2.0);  m_one = make_vec(-1.0, -1.0);
+    init  = make_vec( 1.0,  2.0);  av    = make_vec( 1.0, -1.0);
+    
+    Harmonic = zeta = poly = alt = Gregory = zero; 
+
+    for (k=1; k<=n; k++)
+    {
+        twoThrd += pow(2.0/3.0, k-1);
+        sqrts   += 1.0/sqrt(k);
+              k3 = k*k*k;
+              s  = sin(k); c = cos(k); 
+        Flint   += 1.0/(k3 * s*s);        
+        Cookson += 1.0/(k3 * c*c);
+    } 
+
+    for (kv=init; *(double *)(&kv)<=n; kv+=two)
+    {
+        poly    += one /(kv*(kv+one)); 
+        Harmonic+= one / kv;
+        zeta    += one /(kv*kv);
+        alt     +=  av / kv;  
+        Gregory +=  av /(two*kv - one);
+    }
+    
+#define psum(name,num) printf("%.9f\t%s\n",num,name)
+    psum("(2/3)^k",           twoThrd); psum("k^-0.5",      sqrts);
+    psum("1/k(k+1)",    sum_vec(poly)); psum("Flint Hills", Flint);
+    psum("Cookson Hills",     Cookson); psum("Harmonic", sum_vec(Harmonic));  
+    psum("Riemann Zeta",sum_vec(zeta)); psum("Alternating Harmonic",sum_vec(alt));
+    psum("Gregory",  sum_vec(Gregory));
+    
+    return 0;
+}