chrislo-sourceclassifier 0.2.0 → 0.2.1

data/sources/gcc/raytracer.gcc

@@ -1,125 +0,0 @@
-/* -*- 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

@@ -1,181 +0,0 @@
-#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;
-}

data/sources/gcc/recursive.gcc

@@ -1,68 +0,0 @@
-/*
- * The Computer Language Benchmarks Game
- * http://shootout.alioth.debian.org/
-
- * contributed by bearophile, Jan 24 2006
- * modified by wolfjb, Feb 28 2007
- * modified by alex burlyga, may 16, 2008
- */
-#include <stdio.h>
-#include <stdlib.h>
-
-static inline int ack(register int x, register int y) __attribute__((const));
-static inline int fib(int n) __attribute__((const));
-static inline double fibFP(double n) __attribute__((const));
-static inline int tak(int x, int y, int z) __attribute__((const));
-static inline double takFP(double x, double y, double z) __attribute__((const));
-
-static inline int ack(register int x, register int y){
-  if (x == 0) {
-    return y + 1;
-  }
-
-  return ack(x - 1, ((y | 0) ? ack(x, y - 1) : 1));
-}
-
-static inline int fib(register int n) {
-  if (n < 2) {
-    return 1;
-  }
-  return fib(n - 2) + fib(n - 1);
-}
-
-static inline double fibFP(double n) {
-  if (n < 2.0) {
-    return 1.0;
-  }
-  return fibFP(n - 2.0) + fibFP(n - 1.0);
-}
-
-static inline int tak(register int x, register int y, register int z) {
-  if (y < x) {
-    return tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y));
-  }
-  return z;
-}
-
-static inline double takFP(double x, double y, double z) {
-    if (y < x)
-        return takFP( takFP(x-1.0, y, z), takFP(y-1.0, z, x), takFP(z-1.0, x, y) );
-    return z;
-}
-
-int
-main(int argc, char ** argv) {
-  int n = 3;
-
-  if(argc > 1) {
-    n = strtol(argv[1], NULL, 10) - 1;
-  }
-
-  printf("Ack(3,%d): %d\n", n + 1, ack(3, n+1));
-  printf("Fib(%.1f): %.1f\n", 28.0 + n, fibFP(28.0+n));
-  printf("Tak(%d,%d,%d): %d\n", 3 * n, 2 * n, n, tak(3*n, 2*n, n));
-  printf("Fib(3): %d\n", fib(3));
-  printf("Tak(3.0,2.0,1.0): %.1f\n", takFP(3.0, 2.0, 1.0));
-
-  return 0;
-}

data/sources/gcc/recursive.gcc-2.gcc

@@ -1,55 +0,0 @@
-/*
- * The Computer Language Shootout
- * http://shootout.alioth.debian.org/
-
- * contributed by bearophile, Jan 24 2006
- * modified by wolfjb, Feb 28 2007
- */
-#include <stdio.h>
-
-int ack(int x, int y) {
-  if (x == 0) {
-    return y + 1;
-  }
-
-  return ack(x - 1, ((y | 0) ? ack(x, y - 1) : 1));
-}
-
-int fib(int n) {
-  if (n < 2) {
-    return 1;
-  }
-  return fib(n - 2) + fib(n - 1);
-}
-
-double fibFP(double n) {
-  if (n < 2.0) {
-    return 1.0;
-  }
-  return fibFP(n - 2.0) + fibFP(n - 1.0);
-}
-
-int tak(int x, int y, int z) {
-  if (y < x) {
-    return tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y));
-  }
-  return z;
-}
-
-double takFP(double x, double y, double z) {
-    if (y < x)
-        return takFP( takFP(x-1.0, y, z), takFP(y-1.0, z, x), takFP(z-1.0, x, y) );
-    return z;
-}
-
-int main(int argc, char ** argv) {
-  int n = atoi(argv[1]) - 1;
-
-  printf("Ack(3,%d): %d\n", n + 1, ack(3, n+1));
-  printf("Fib(%.1f): %.1f\n", 28.0 + n, fibFP(28.0+n));
-  printf("Tak(%d,%d,%d): %d\n", 3 * n, 2 * n, n, tak(3*n, 2*n, n));
-  printf("Fib(3): %d\n", fib(3));
-  printf("Tak(3.0,2.0,1.0): %.1f\n", takFP(3.0, 2.0, 1.0));
-
-  return 0;
-}

data/sources/gcc/regexdna.gcc-2.gcc

@@ -1,126 +0,0 @@
-/*
-** The Computer Language Shootout
-** http://shootout.alioth.debian.org/
-** contributed by Mike Pall
-**
-** regex-dna benchmark using PCRE
-**
-** compile with:
-**   gcc -O3 -fomit-frame-pointer -o regexdna regexdna.c -lpcre
-*/
-
-#define __USE_STRING_INLINES
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <pcre.h>
-
-typedef struct fbuf {
-  char *buf;
-  size_t size, len;
-} fbuf_t;
-
-static void fb_init(fbuf_t *b)
-{
-  b->buf = NULL;
-  b->len = b->size = 0;
-}
-
-static char *fb_need(fbuf_t *b, size_t need)
-{
-  need += b->len;
-  if (need > b->size) {
-    if (b->size == 0) b->size = need;
-    else while (need > b->size) b->size += b->size;
-    if (!(b->buf = realloc(b->buf, b->size))) exit(1);
-  }
-  return b->buf+b->len;
-}
-
-#define FB_MINREAD	(3<<16)
-
-/* Read all of a stdio stream into dst buffer. */
-static size_t fb_readall(fbuf_t *dst, FILE *fp)
-{
-  char *dp;
-  int n;
-  for (dp = fb_need(dst, FB_MINREAD);
-       (n = fread(dp, 1, dst->size-dst->len, fp)) > 0;
-       dp = fb_need(dst, FB_MINREAD)) dst->len += n;
-  if (ferror(fp)) exit(1);
-  return dst->len;
-}
-
-/* Substitute pattern p with replacement r, copying from src to dst buffer. */
-static size_t fb_subst(fbuf_t *dst, fbuf_t *src, const char *p, const char *r)
-{
-  pcre *re;
-  pcre_extra *re_ex;
-  const char *re_e;
-  char *dp;
-  int re_eo, m[3], pos, rlen, clen;
-  if (!(re = pcre_compile(p, PCRE_CASELESS, &re_e, &re_eo, NULL))) exit(1);
-  re_ex = pcre_study(re, 0, &re_e);
-  for (dst->len = 0, rlen = strlen(r), pos = 0;
-       pcre_exec(re, re_ex, src->buf, src->len, pos, 0, m, 3) >= 0;
-       pos = m[1]) {
-    clen = m[0]-pos;
-    dp = fb_need(dst, clen+rlen);
-    dst->len += clen+rlen;
-    memcpy(dp, src->buf+pos, clen);
-    memcpy(dp+clen, r, rlen);
-  }
-  clen = src->len-pos;
-  dp = fb_need(dst, clen);
-  dst->len += clen;
-  memcpy(dp, src->buf+pos, clen);
-  return dst->len;
-}
-
-/* Count all matches with pattern p in src buffer. */
-static int fb_countmatches(fbuf_t *src, const char *p)
-{
-  pcre *re;
-  pcre_extra *re_ex;
-  const char *re_e;
-  int re_eo, m[3], pos, count;
-  if (!(re = pcre_compile(p, PCRE_CASELESS, &re_e, &re_eo, NULL))) exit(1);
-  re_ex = pcre_study(re, 0, &re_e);
-  for (count = 0, pos = 0;
-       pcre_exec(re, re_ex, src->buf, src->len, pos, 0, m, 3) >= 0;
-       pos = m[1]) count++;
-  return count;
-}
-
-static const char *variants[] = {
-  "agggtaaa|tttaccct",         "[cgt]gggtaaa|tttaccc[acg]",
-  "a[act]ggtaaa|tttacc[agt]t", "ag[act]gtaaa|tttac[agt]ct",
-  "agg[act]taaa|ttta[agt]cct", "aggg[acg]aaa|ttt[cgt]ccct",
-  "agggt[cgt]aa|tt[acg]accct", "agggta[cgt]a|t[acg]taccct",
-  "agggtaa[cgt]|[acg]ttaccct", NULL
-};
-
-static const char *subst[] = {
-  "B", "(c|g|t)", "D", "(a|g|t)",   "H", "(a|c|t)", "K", "(g|t)",
-  "M", "(a|c)",   "N", "(a|c|g|t)", "R", "(a|g)",   "S", "(c|g)",
-  "V", "(a|c|g)", "W", "(a|t)",     "Y", "(c|t)",   NULL
-};
-
-int main(int argc, char **argv)
-{
-  fbuf_t seq[2];
-  const char **pp;
-  size_t ilen, clen, slen;
-  int flip;
-  fb_init(&seq[0]);
-  fb_init(&seq[1]);
-  ilen = fb_readall(&seq[0], stdin);
-  clen = fb_subst(&seq[1], &seq[0], ">.*|\n", "");
-  for (pp = variants; *pp; pp++)
-    printf("%s %d\n", *pp, fb_countmatches(&seq[1], *pp));
-  for (slen = 0, flip = 1, pp = subst; *pp; pp += 2, flip = 1-flip)
-    slen = fb_subst(&seq[1-flip], &seq[flip], *pp, pp[1]);
-  printf("\n%zu\n%zu\n%zu\n", ilen, clen, slen);
-  return 0;
-}
-