chrislo-sourceclassifier 0.2.0

data/sources/gcc/pidigits.gcc

@@ -0,0 +1,105 @@
+/*
+** The Computer Language Shootout
+** http://shootout.alioth.debian.org/
+** contributed by Mike Pall
+**
+**   gcc -O3 -fomit-frame-pointer -o pidigits pidigits.c -lgmp
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <gmp.h>
+
+typedef struct ctx_s {
+  mpz_t q, r, s, t;	/* Transformation matrix components. */
+  mpz_t u, v, w;	/* Temporary numbers. */
+  int d, i, n;		/* Counters. */
+  char digits[10+1];	/* Accumulated digits for one line. */
+} ctx_t;
+
+/* Compose matrix with numbers on the right. */
+static void compose_r(ctx_t *c, int bq, int br, int bs, int bt)
+{
+  mpz_mul_si(c->u, c->r, bs);
+  mpz_mul_si(c->r, c->r, bq);
+  mpz_mul_si(c->v, c->t, br);
+  mpz_add(c->r, c->r, c->v);
+  mpz_mul_si(c->t, c->t, bt);
+  mpz_add(c->t, c->t, c->u);
+  mpz_mul_si(c->s, c->s, bt);
+  mpz_mul_si(c->u, c->q, bs);
+  mpz_add(c->s, c->s, c->u);
+  mpz_mul_si(c->q, c->q, bq);
+}
+
+/* Compose matrix with numbers on the left. */
+static void compose_l(ctx_t *c, int bq, int br, int bs, int bt)
+{
+  mpz_mul_si(c->r, c->r, bt);
+  mpz_mul_si(c->u, c->q, br);
+  mpz_add(c->r, c->r, c->u);
+  mpz_mul_si(c->u, c->t, bs);
+  mpz_mul_si(c->t, c->t, bt);
+  mpz_mul_si(c->v, c->s, br);
+  mpz_add(c->t, c->t, c->v);
+  mpz_mul_si(c->s, c->s, bq);
+  mpz_add(c->s, c->s, c->u);
+  mpz_mul_si(c->q, c->q, bq);
+}
+
+/* Extract one digit. */
+static int extract(ctx_t *c, unsigned int j)
+{
+  mpz_mul_ui(c->u, c->q, j);
+  mpz_add(c->u, c->u, c->r);
+  mpz_mul_ui(c->v, c->s, j);
+  mpz_add(c->v, c->v, c->t);
+  mpz_tdiv_q(c->w, c->u, c->v);
+  return mpz_get_ui(c->w);
+}
+
+/* Print one digit. Returns 1 for the last digit. */
+static int prdigit(ctx_t *c, int y)
+{
+  c->digits[c->d++] = '0'+y;
+  if (++c->i % 10 == 0 || c->i == c->n) {
+    c->digits[c->d] = '\0';
+    printf("%-10s\t:%d\n", c->digits, c->i);
+    c->d = 0;
+  }
+  return c->i == c->n;
+}
+
+/* Generate successive digits of PI. */
+static void pidigits(ctx_t *c)
+{
+  int k = 1;
+  c->d = 0;
+  c->i = 0;
+  mpz_init_set_ui(c->q, 1);
+  mpz_init_set_ui(c->r, 0);
+  mpz_init_set_ui(c->s, 0);
+  mpz_init_set_ui(c->t, 1);
+  mpz_init(c->u);
+  mpz_init(c->v);
+  mpz_init(c->w);
+  for (;;) {
+    int y = extract(c, 3);
+    if (y == extract(c, 4)) {
+      if (prdigit(c, y)) return;
+      compose_r(c, 10, -10*y, 0, 1);
+    } else {
+      compose_l(c, k, 4*k+2, 0, 2*k+1);
+      k++;
+    }
+  }
+}
+
+int main(int argc, char **argv)
+{
+  ctx_t c;
+  c.n = argc > 1 ? atoi(argv[1]) : 27;
+  pidigits(&c);
+  return 0;
+}
+

data/sources/gcc/primes.gcc

@@ -0,0 +1,75 @@
+/* The Computer Language Benchmarks Game
+   http://shootout.alioth.debian.org/
+   contributed by Steven Noonan
+*/
+ 
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+int
+isPrime ( unsigned long _candidate )
+{
+    unsigned long i, limit;
+
+	/* 0 and 1 aren't prime. */
+    if ( _candidate < 2 ) return 0;
+
+    /* All numbers less than 4 are prime, except '1' */
+    if ( _candidate < 4 ) return -1;
+
+    /* Other than 2, even numbers are not prime */
+    if ( _candidate % 2 == 0 ) return 0;
+
+	/* All primes are of the form 6k+i (where i = -1 or 1), except for 2 or 3. */
+    if ( ( _candidate + 1 ) % 6 != 0
+      && ( _candidate - 1 ) % 6 != 0 )
+    	return 0;
+
+    /*
+       if n is composite then it can be factored into two values,
+       at least one of which is less than or equal to sqrt(n)
+     */
+    limit = (unsigned long)sqrt ((double)_candidate);
+
+    /* Now test all other odd numbers up to sqrt(n) */
+    for ( i = 3; i <= limit; i += 2 ) if ( _candidate % i == 0 ) return 0;
+
+    return 1;
+}
+
+unsigned long
+nthPrime ( unsigned long _primeToFind )
+{
+    unsigned long count = 0, num;
+    for ( num = 1; count < _primeToFind; num++ )
+    {
+        if ( isPrime ( num ) )
+        {
+            count++;
+        }
+    }
+    
+    /* Returning num-1 because we hit a num++ between isPrime and here. */
+    return num - 1;
+}
+
+int
+main ( int argc, char **argv )
+{
+	unsigned long i, n;
+	
+	if ( argc < 2 ) return -1;
+
+	n = atoi(argv[1]);
+	
+	printf ( "1st prime is %d\n", nthPrime ( 1 ) );
+	printf ( "2nd prime is %d\n", nthPrime ( 2 ) );
+
+    for ( i = 10 * n; i <= 50 * n; i += 10 * n )
+    {
+        printf ( "%uth prime is %u\n", i, nthPrime ( i ) );
+    }
+
+    return 0;
+}

data/sources/gcc/prodcons.gcc

@@ -0,0 +1,86 @@
+/* -*- mode: c -*-
+ * $Id: prodcons.gcc,v 1.1.1.1 2004-05-19 18:11:09 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <pthread.h>
+
+pthread_mutex_t mutex;
+pthread_cond_t control;
+void producer(int *arg);
+void consumer(int *arg);
+int count, data, consumed, produced;
+
+
+int
+main(int argc, char *argv[]) {
+    int n = ((argc == 2) ? atoi(argv[1]) : 1);
+    pthread_t t1, t2;
+    
+    count = data = consumed = produced = 0;
+
+    if (pthread_mutex_init(&mutex, NULL)) {
+	perror("pthread_mutex_init");
+	exit(1);
+    }
+    if (pthread_cond_init(&control, NULL)) {
+	perror("pthread_cond_init");
+	exit(1);
+    }
+    if (pthread_create(&t1, (pthread_attr_t *)NULL,
+		       (void * (*)(void *))producer, (void *)&n)) {
+	perror("pthread_create");
+	exit(1);
+    }
+    if (pthread_create(&t2, (pthread_attr_t *)NULL,
+		       (void * (*)(void *))consumer, (void *)&n)) {
+	perror("pthread_create");
+	exit(1);
+    }
+  
+    pthread_join(t1, NULL);
+    pthread_join(t2, NULL);
+    fprintf(stdout, "%d %d\n", produced, consumed);
+    return(0);
+}
+
+
+void producer(int *arg) {
+    int i, n = *arg;
+    for (i=1; i<=n; i++) {
+	pthread_mutex_lock(&mutex);
+	while (count == 1) {
+	    pthread_cond_wait(&control, &mutex);
+	}
+	data = i;
+	count = 1;
+	pthread_cond_signal(&control);
+	pthread_mutex_unlock(&mutex);
+	produced++;
+    }
+}
+ 
+
+void consumer(int *arg) {
+    int i = 0, n = *arg;
+    while (1) {
+	pthread_mutex_lock(&mutex);
+	while (count == 0) {
+	    pthread_cond_wait(&control, &mutex);
+	}
+	i = data;
+	count = 0;
+	pthread_cond_signal(&control);
+	pthread_mutex_unlock(&mutex);
+	consumed++;
+	if (i == n) return;
+    }
+}
+

data/sources/gcc/random.gcc

@@ -0,0 +1,29 @@
+/* -*- mode: c -*-
+ * $Id: random.gcc,v 1.1.1.1 2004-05-19 18:11:15 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define IM 139968
+#define IA 3877
+#define IC 29573
+
+inline double gen_random(double max) {
+    static long last = 42;
+    
+    last = (last * IA + IC) % IM;
+    return( max * last / IM );
+}
+
+int main(int argc, char *argv[]) {
+    int N = ((argc == 2) ? atoi(argv[1]) : 1) - 1;
+    
+    while (N--) {
+	gen_random(100.0);
+    }
+    printf("%.9f\n", gen_random(100.0));
+    return(0);
+}

data/sources/gcc/raytracer.gcc

@@ -0,0 +1,125 @@
+/* -*- mode: c -*-
+ * The Great Computer Language Shootout
+ * http://shootout.alioth.debian.org/
+ *
+ * Jon Harrop, 2005
+ * Compile: gcc -Wall -O3 -ffast-math -lm -std=c99 raytracer.c -o raytracer
+ */
+
+
+#include <float.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+double delta;
+
+typedef struct { double x, y, z; } Vec;
+Vec vec(double ix, double iy, double iz)
+{ Vec a; a.x = ix; a.y = iy; a.z = iz; return a; }
+Vec add(Vec a, Vec b) { return vec(a.x + b.x, a.y + b.y, a.z + b.z); }
+Vec sub(Vec a, Vec b) { return vec(a.x - b.x, a.y - b.y, a.z - b.z); }
+Vec scale(double a, Vec b) { return vec(a * b.x, a * b.y, a * b.z); }
+double dot(Vec a, Vec b) { return a.x*b.x + a.y*b.y + a.z*b.z; }
+Vec unitise(Vec a) { return scale(1 / sqrt(dot(a, a)), a); }
+
+typedef struct { Vec orig, dir; } Ray;
+Ray ray(Vec o, Vec d) { Ray r; r.orig = o; r.dir = d; return r; }
+
+typedef enum {SphereTag, GroupTag} Tag;
+typedef struct { Vec center; double radius; } Sphere;
+Sphere sphere(Vec c, double r) { Sphere s; s.center=c; s.radius=r; return s; }
+typedef struct { Sphere bound; int n; void *child; } Group;
+typedef struct { Tag tag; union { Sphere s; Group g; } data; } Scene;
+
+double ray_sphere(const Ray *r, const Sphere *s) {
+  Vec v = sub(s->center, r->orig);
+  double b = dot(v, r->dir), disc = b*b - dot(v, v) + s->radius * s->radius;
+  if (disc < 0) return INFINITY;
+  double d = sqrt(disc), t2 = b + d;
+  if (t2 < 0) return INFINITY;
+  double t1 = b - d;
+  return (t1 > 0 ? t1 : t2);
+}
+
+void intersect(double *lambda, Vec *normal, const Ray *r, const Scene scene) {
+  switch (scene.tag) {
+  case SphereTag : {
+    Sphere s = scene.data.s;
+    double l = ray_sphere(r, &s);
+    if (l >= *lambda) return;
+    *lambda = l;
+    *normal = unitise(add(r->orig, sub(scale(l, r->dir), s.center)));
+    break;
+  }
+  case GroupTag : {
+    Group g = scene.data.g;
+    if (ray_sphere(r, &g.bound) >= *lambda) return;
+    for (int i=0; i<g.n; ++i)
+      intersect(lambda, normal, r, ((Scene *)g.child)[i]);
+    break;
+  }
+  }
+}
+
+double ray_trace(Vec light, Ray r, Scene scene) {
+  double lambda = INFINITY;
+  Vec n = vec(0, 0, 0);
+  intersect(&lambda, &n, &r, scene);
+  if (lambda == INFINITY) return 0;
+  double g = dot(n, light), l = INFINITY;
+  if (g <= 0) return 0.;
+  Ray r2 = ray(add(r.orig, scale(lambda, add(r.dir, scale(delta, n)))),
+	       light);
+  intersect(&l, &n, &r2, scene);
+  return (l == INFINITY ? g : 0);
+}
+
+Scene create(int level, double r, double x, double y, double z) {
+  Scene scene;
+  if (level == 1) {
+    scene.tag = SphereTag;
+    scene.data.s = sphere(vec(x, y, z), r);
+  } else {
+    Group *g = &scene.data.g;
+    Scene *cs;
+    scene.tag = GroupTag;
+    g->bound = sphere(vec(x, y, z), 3*r);
+    g->n = 5;
+    g->child = cs = (Scene *)malloc(g->n * sizeof(Scene));
+    double rn = 3*r/sqrt(12.);
+    for (int i=0; i<4; ++i)
+      cs[i] = create(level-1, r/2,
+		     x - ((i&1)*2-1)*rn, y + rn, z - ((i/2)*2-1)*rn);
+    cs[g->n - 1] = create(1, r, x, y, z);
+  }
+  return scene;
+}
+
+void destroy(Scene scene) {
+  if (scene.tag == GroupTag) {
+    for (int i=0; i<scene.data.g.n; ++i)
+      destroy(((Scene *)scene.data.g.child)[i]);
+    free(scene.data.g.child);
+  }
+}
+
+int main(int argc, char *argv[]) {
+  delta = sqrt(DBL_EPSILON);
+  int level = 6, n = (argc==2 ? atoi(argv[1]) : 256), ss = 4;
+  Vec light = sub(vec(0, 0, 0), unitise(vec(-1, -3, 2)));
+  Scene scene = create(level, 1, 0, -1, 0); // Build the scene
+  printf("P5\n%d %d\n255\n", n, n);
+  for (int y=n-1; y>=0; --y)
+    for (int x=0; x<n; ++x) {
+      double g=0;
+      for (int dx=0; dx<ss; ++dx)
+	for (int dy=0; dy<ss; ++dy) {
+	  Vec d=vec(x+(double)dx/ss-n/2., y+(double)dy/ss-n/2., n);
+	  g += ray_trace(light, ray(vec(0, 0, -4), unitise(d)), scene);
+	}
+      printf("%c", (char)(.5 + 255*g/(ss*ss)));
+    }
+  destroy(scene);
+  return 0;
+}

data/sources/gcc/raytracer.gcc-2.gcc

@@ -0,0 +1,181 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <float.h>
+
+#ifndef INFINITY
+# define INFINITY DBL_MAX
+#endif
+
+#define DELTA 1.49012e-08
+
+typedef struct { double x, y, z; } Vec;
+static __inline__ Vec vec(double ix, double iy, double iz)
+{ Vec a; a.x = ix; a.y = iy; a.z = iz; return a; }
+static __inline__ Vec add(Vec a, Vec b) { return vec(a.x + b.x, a.y + b.y, a.z + b.z); }
+static __inline__ Vec sub(Vec a, Vec b) { return vec(a.x - b.x, a.y - b.y, a.z - b.z); }
+static __inline__ Vec scale(double a, Vec b) { return vec(a * b.x, a * b.y, a * b.z); }
+static __inline__ double dot(Vec a, Vec b) { return a.x*b.x + a.y*b.y + a.z*b.z; }
+static __inline__ Vec unitise(Vec a) { return scale(1 / sqrt(dot(a, a)), a); }
+
+typedef struct { Vec orig, dir; } Ray;
+static __inline__ Ray ray(Vec o, Vec d) { Ray r; r.orig = o; r.dir = d; return r; }
+
+typedef struct _tSphere Sphere;
+typedef struct _tGroup Group;
+typedef struct _tScene_Object Scene;
+
+#define SCENE_OBJECT(T) \
+   void (*intersect) (T*, double *, Vec *, const Ray *); \
+   void (*destroy) (T *)
+
+struct _tScene_Object
+{
+   SCENE_OBJECT(Scene);
+};
+static Scene *scene_new (int, double, double, double, double);
+
+struct _tSphere
+{ 
+   SCENE_OBJECT(Sphere);
+   Vec center; double radius; 
+};
+
+static __inline__ double ray_sphere (const Ray *r, const Sphere *s) 
+{
+   double d, t1, t2;
+   Vec v = sub(s->center, r->orig);
+   double b = dot(v, r->dir), disc = b*b - dot(v, v) + s->radius * s->radius;
+   if (disc < 0) return INFINITY;
+   d = sqrt(disc), t2 = b + d;
+   if (t2 < 0) return INFINITY;
+   t1 = b - d;
+   return (t1 > 0 ? t1 : t2);
+}
+
+static void sphere_intersect (Sphere *s, double *lambda, Vec *normal, const Ray *r)
+{
+   double l = ray_sphere(r, s);
+   if (l >= *lambda) return;
+   *lambda = l;
+   *normal = unitise (add(r->orig, sub(scale(l, r->dir), s->center)));
+}
+
+static void sphere_destroy (Sphere *s)
+{
+   free ((char *)s);
+}
+
+static Sphere *sphere_new (double r, double x, double y, double z)
+{
+   Sphere *s = (Sphere *) calloc (1, sizeof (Sphere));
+   s->intersect = sphere_intersect;
+   s->destroy = sphere_destroy;
+   s->center=vec(x,y,z); s->radius=r; 
+   return s; 
+}
+
+struct _tGroup
+{
+   SCENE_OBJECT(Group);
+   Sphere *bound;
+#define NUM_GROUP_MEMBERS 5
+   Scene *members[NUM_GROUP_MEMBERS];
+};
+
+static void group_intersect (Group *g, double *lambda, Vec *normal, const Ray *r)
+{
+   int i;
+
+   if (ray_sphere (r, g->bound) >= *lambda) 
+     return;
+
+   for (i = 0; i < NUM_GROUP_MEMBERS; i++)
+     {
+	Scene *s = g->members[i];
+	(*s->intersect) (s, lambda, normal, r);
+     }
+}
+
+static void group_destroy (Group *g)
+{
+   int i;
+
+   (*g->bound->destroy) (g->bound);
+   for (i = 0; i < NUM_GROUP_MEMBERS; i++)
+     {
+	Scene *s = g->members[i];
+	(*s->destroy) (s);
+     }
+   free ((char *)g);
+}
+
+static Group *group_new (int level, double r, double x, double y, double z)
+{
+   static double dz[NUM_GROUP_MEMBERS] = {-1, -1, 1, 1, 0};
+   static double dx[NUM_GROUP_MEMBERS] = {-1, 1, -1, 1, 0};
+   double rn;
+   int i;
+   Group *g = (Group *)calloc (1, sizeof (Group));
+   g->intersect = group_intersect;
+   g->destroy = group_destroy;
+   g->bound = sphere_new (3*r, x, y, z);
+   rn = 3*r/sqrt(12.0);
+   for (i = 0; i < NUM_GROUP_MEMBERS-1; i++)
+     g->members[i] = scene_new (level, 0.5*r, x-dx[i]*rn, y+rn, z-dz[i]*rn);
+   g->members[NUM_GROUP_MEMBERS-1] = scene_new (1, r, x, y, z);
+   
+   return g;
+}
+
+static Scene *scene_new (int level, double r, double x, double y, double z)
+{
+   if (level == 1)
+     return (Scene *) sphere_new (r, x, y, z);
+   return (Scene *) group_new (level-1, r, x, y, z);
+}
+
+
+static double ray_trace (Vec light, Ray r, Scene *scene) 
+{
+   double lambda = INFINITY, l, g;
+   Ray r2;
+   Vec n = vec(0, 0, 0);
+   (*scene->intersect) (scene, &lambda, &n, &r);
+   if (lambda == INFINITY) return 0.0;
+   if ((g = dot(n, light)) <= 0.0)
+     return 0.0;
+   l = INFINITY;
+   r2 = ray(add(r.orig, scale(lambda, add(r.dir, scale(DELTA, n)))), light);
+   (*scene->intersect) (scene, &l, &n, &r2);
+   return (l == INFINITY ? g : 0.0);
+}
+
+int main (int argc, char *argv[]) 
+{
+   int x, y, dx, dy, level, n, ss;
+   Vec light;
+   Scene *scene;
+   level = 6, n = (argc==2 ? atoi(argv[1]) : 256), ss = 4;
+   light = sub(vec(0, 0, 0), unitise(vec(-1, -3, 2)));
+   scene = scene_new (level, 1, 0, -1, 0);  /* Build the scene */
+   fprintf (stdout, "P5\n%d %d\n255\n", n, n);
+   for (y=n-1; y>=0; --y)
+     {
+	for (x=0; x<n; ++x) 
+	  {
+	     double g=0.0;
+	     for (dx=0; dx<ss; ++dx)
+	       {
+		  for (dy=0; dy<ss; ++dy) 
+		    {
+		       Vec d=vec(x+(double)dx/ss-n/2., y+(double)dy/ss-n/2., n);
+		       g += ray_trace(light, ray(vec(0, 0, -4), unitise(d)), scene);
+		    }
+	       }
+	     putc ((char)(.5 + 255*g/(ss*ss)),stdout);
+	  }
+    }
+   (*scene->destroy)(scene);
+   return 0;
+}