chrislo-sourceclassifier 0.2.0

data/sources/gcc/moments.gcc

@@ -0,0 +1,120 @@
+/* -*- mode: c -*-
+ * $Id: moments.gcc,v 1.1.1.1 2004-05-19 18:10:47 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ * from Waldek Hebisch
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#define MAXLINELEN 128
+
+/* kmedian permutes elements of a to get
+   a[i]<=a[k] for i<k
+   a[i]>=a[k] for i>k
+	See. N. Wirth, Algorithms+data structures = Programs
+*/
+
+void kmedian(double *a, int n, int k) 
+{
+	while (1){
+		int j=random()%n; 
+		double b = a[j];
+		int i=0;
+        	j = n-1;
+        	while(1) {
+        	    while( a[i]<b ) i++;
+        	    while( a[j]>b ) j--;
+        	    if(i<j) {
+                	double tmp=a[i];
+                	a[i]=a[j];
+                	a[j]=tmp;
+                	i++;
+                	j--;
+       		    } else {
+                	if(a[j]<b) j++;
+                	if(a[i]>b) i--;
+			break;
+        	    }
+        	}
+		if(i<k) {
+			k-=i+1;
+			n-=i+1;
+			a+=i+1;
+		} else if (j>k) { 
+			n=j;
+		} else return;
+	}
+}
+
+double max(double *a, int n)
+{
+	int j;
+	double temp=a[0];
+	for(j=1;j<n;j++) { 
+		if(a[j]>temp) {
+			temp=a[j];
+		}
+	}
+	return temp;
+}
+
+
+int
+main() {
+    char line[MAXLINELEN];
+    int i, n = 0, mid = 0;
+    double sum = 0.0;
+    double mean = 0.0;
+    double average_deviation = 0.0;
+    double standard_deviation = 0.0;
+    double variance = 0.0;
+    double skew = 0.0;
+    double kurtosis = 0.0;
+    double median = 0.0;
+    double deviation = 0.0;
+    int array_size = 4096;
+
+    double *nums = (double *)malloc(array_size * sizeof(double));
+
+    while (fgets(line, MAXLINELEN, stdin)) {
+	sum += (nums[n++] = atof(line));
+	if (n == array_size) {
+	    array_size *= 2;
+	    nums = (double *)realloc(nums, array_size * sizeof(double));
+	}
+    }
+    mean = sum/n;
+    for (i=0; i<n; i++) {
+	double dev = nums[i] - mean;
+	double dev2=dev*dev;
+	double dev3=dev2*dev;
+	double dev4=dev3*dev;
+	average_deviation += fabs(dev);
+	variance += dev2 /*pow(deviation,2)*/;
+	skew += dev3 /* pow(deviation,3) */;
+	kurtosis += dev4 /* pow(deviation,4) */;
+    }
+    average_deviation /= n;
+    variance /= (n - 1);
+    standard_deviation = sqrt(variance);
+    if (variance) {
+	skew /= (n * variance * standard_deviation);
+	kurtosis = (kurtosis/(n * variance * variance)) - 3.0;
+    }
+    mid = (n/2);
+    kmedian(nums, n, mid); 
+    median = n % 2 ? nums[mid] : (nums[mid] + max(nums,mid))/2;
+    free(nums);
+    printf("n:                  %d\n", n);
+    printf("median:             %f\n", median);
+    printf("mean:               %f\n", mean);
+    printf("average_deviation:  %f\n", average_deviation);
+    printf("standard_deviation: %f\n", standard_deviation);
+    printf("variance:           %f\n", variance);
+    printf("skew:               %f\n", skew);
+    printf("kurtosis:           %f\n", kurtosis);
+
+    return(0);
+}

data/sources/gcc/nbody.gcc

@@ -0,0 +1,142 @@
+/*
+ * The Great Computer Language Shootout
+ * http://shootout.alioth.debian.org/
+ *
+ * contributed by Christoph Bauer
+ *  
+ */
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define pi 3.141592653589793
+#define solar_mass (4 * pi * pi)
+#define days_per_year 365.24
+
+struct planet {
+  double x, y, z;
+  double vx, vy, vz;
+  double mass;
+};
+
+void advance(int nbodies, struct planet * bodies, double dt)
+{
+  int i, j;
+
+  for (i = 0; i < nbodies; i++) {
+    struct planet * b = &(bodies[i]);
+    for (j = i + 1; j < nbodies; j++) {
+      struct planet * b2 = &(bodies[j]);
+      double dx = b->x - b2->x;
+      double dy = b->y - b2->y;
+      double dz = b->z - b2->z;
+      double distance = sqrt(dx * dx + dy * dy + dz * dz);
+      double mag = dt / (distance * distance * distance);
+      b->vx -= dx * b2->mass * mag;
+      b->vy -= dy * b2->mass * mag;
+      b->vz -= dz * b2->mass * mag;
+      b2->vx += dx * b->mass * mag;
+      b2->vy += dy * b->mass * mag;
+      b2->vz += dz * b->mass * mag;
+    }
+  }
+  for (i = 0; i < nbodies; i++) {
+    struct planet * b = &(bodies[i]);
+    b->x += dt * b->vx;
+    b->y += dt * b->vy;
+    b->z += dt * b->vz;
+  }
+}
+
+double energy(int nbodies, struct planet * bodies)
+{
+  double e;
+  int i, j;
+
+  e = 0.0;
+  for (i = 0; i < nbodies; i++) {
+    struct planet * b = &(bodies[i]);
+    e += 0.5 * b->mass * (b->vx * b->vx + b->vy * b->vy + b->vz * b->vz);
+    for (j = i + 1; j < nbodies; j++) {
+      struct planet * b2 = &(bodies[j]);
+      double dx = b->x - b2->x;
+      double dy = b->y - b2->y;
+      double dz = b->z - b2->z;
+      double distance = sqrt(dx * dx + dy * dy + dz * dz);
+      e -= (b->mass * b2->mass) / distance;
+    }
+  }
+  return e;
+}
+
+void offset_momentum(int nbodies, struct planet * bodies)
+{
+  double px = 0.0, py = 0.0, pz = 0.0;
+  int i;
+  for (i = 0; i < nbodies; i++) {
+    px += bodies[i].vx * bodies[i].mass;
+    py += bodies[i].vy * bodies[i].mass;
+    pz += bodies[i].vz * bodies[i].mass;
+  }
+  bodies[0].vx = - px / solar_mass;
+  bodies[0].vy = - py / solar_mass;
+  bodies[0].vz = - pz / solar_mass;
+}
+
+#define NBODIES 5
+struct planet bodies[NBODIES] = {
+  {                               /* sun */
+    0, 0, 0, 0, 0, 0, solar_mass
+  },
+  {                               /* jupiter */
+    4.84143144246472090e+00,
+    -1.16032004402742839e+00,
+    -1.03622044471123109e-01,
+    1.66007664274403694e-03 * days_per_year,
+    7.69901118419740425e-03 * days_per_year,
+    -6.90460016972063023e-05 * days_per_year,
+    9.54791938424326609e-04 * solar_mass
+  },
+  {                               /* saturn */
+    8.34336671824457987e+00,
+    4.12479856412430479e+00,
+    -4.03523417114321381e-01,
+    -2.76742510726862411e-03 * days_per_year,
+    4.99852801234917238e-03 * days_per_year,
+    2.30417297573763929e-05 * days_per_year,
+    2.85885980666130812e-04 * solar_mass
+  },
+  {                               /* uranus */
+    1.28943695621391310e+01,
+    -1.51111514016986312e+01,
+    -2.23307578892655734e-01,
+    2.96460137564761618e-03 * days_per_year,
+    2.37847173959480950e-03 * days_per_year,
+    -2.96589568540237556e-05 * days_per_year,
+    4.36624404335156298e-05 * solar_mass
+  },
+  {                               /* neptune */
+    1.53796971148509165e+01,
+    -2.59193146099879641e+01,
+    1.79258772950371181e-01,
+    2.68067772490389322e-03 * days_per_year,
+    1.62824170038242295e-03 * days_per_year,
+    -9.51592254519715870e-05 * days_per_year,
+    5.15138902046611451e-05 * solar_mass
+  }
+};
+
+int main(int argc, char ** argv)
+{
+  int n = atoi(argv[1]);
+  int i;
+
+  offset_momentum(NBODIES, bodies);
+  printf ("%.9f\n", energy(NBODIES, bodies));
+  for (i = 1; i <= n; i++)
+    advance(NBODIES, bodies, 0.01);
+  printf ("%.9f\n", energy(NBODIES, bodies));
+  return 0;
+}
+

data/sources/gcc/nbody.gcc-2.gcc

@@ -0,0 +1,143 @@
+/*
+ * The Computer Language Benchmarks Game
+ * http://shootout.alioth.debian.org/
+ *
+ * contributed by Christoph Bauer
+ * modified by bearophile
+ */
+
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define pi 3.141592653589793
+#define solar_mass (4 * pi * pi)
+#define days_per_year 365.24
+
+struct planet {
+  double x, y, z;
+  double vx, vy, vz;
+  double mass;
+};
+
+void advance(int nbodies, struct planet * bodies, double dt)
+{
+  int i, j;
+
+  for (i = 0; i < nbodies; i++) {
+    struct planet * b = &(bodies[i]);
+    for (j = i + 1; j < nbodies; j++) {
+      struct planet * b2 = &(bodies[j]);
+      double dx = b->x - b2->x;
+      double dy = b->y - b2->y;
+      double dz = b->z - b2->z;
+      double distance_squared = dx * dx + dy * dy + dz * dz;
+      double distance = sqrt(distance_squared);
+      double mag = dt / (distance * distance_squared);
+      b->vx -= dx * b2->mass * mag;
+      b->vy -= dy * b2->mass * mag;
+      b->vz -= dz * b2->mass * mag;
+      b2->vx += dx * b->mass * mag;
+      b2->vy += dy * b->mass * mag;
+      b2->vz += dz * b->mass * mag;
+    }
+  }
+  for (i = 0; i < nbodies; i++) {
+    struct planet * b = &(bodies[i]);
+    b->x += dt * b->vx;
+    b->y += dt * b->vy;
+    b->z += dt * b->vz;
+  }
+}
+
+double energy(int nbodies, struct planet * bodies)
+{
+  double e;
+  int i, j;
+
+  e = 0.0;
+  for (i = 0; i < nbodies; i++) {
+    struct planet * b = &(bodies[i]);
+    e += 0.5 * b->mass * (b->vx * b->vx + b->vy * b->vy + b->vz * b->vz);
+    for (j = i + 1; j < nbodies; j++) {
+      struct planet * b2 = &(bodies[j]);
+      double dx = b->x - b2->x;
+      double dy = b->y - b2->y;
+      double dz = b->z - b2->z;
+      double distance = sqrt(dx * dx + dy * dy + dz * dz);
+      e -= (b->mass * b2->mass) / distance;
+    }
+  }
+  return e;
+}
+
+void offset_momentum(int nbodies, struct planet * bodies)
+{
+  double px = 0.0, py = 0.0, pz = 0.0;
+  int i;
+  for (i = 0; i < nbodies; i++) {
+    px += bodies[i].vx * bodies[i].mass;
+    py += bodies[i].vy * bodies[i].mass;
+    pz += bodies[i].vz * bodies[i].mass;
+  }
+  bodies[0].vx = - px / solar_mass;
+  bodies[0].vy = - py / solar_mass;
+  bodies[0].vz = - pz / solar_mass;
+}
+
+#define NBODIES 5
+struct planet bodies[NBODIES] = {
+  {                               /* sun */
+    0, 0, 0, 0, 0, 0, solar_mass
+  },
+  {                               /* jupiter */
+    4.84143144246472090e+00,
+    -1.16032004402742839e+00,
+    -1.03622044471123109e-01,
+    1.66007664274403694e-03 * days_per_year,
+    7.69901118419740425e-03 * days_per_year,
+    -6.90460016972063023e-05 * days_per_year,
+    9.54791938424326609e-04 * solar_mass
+  },
+  {                               /* saturn */
+    8.34336671824457987e+00,
+    4.12479856412430479e+00,
+    -4.03523417114321381e-01,
+    -2.76742510726862411e-03 * days_per_year,
+    4.99852801234917238e-03 * days_per_year,
+    2.30417297573763929e-05 * days_per_year,
+    2.85885980666130812e-04 * solar_mass
+  },
+  {                               /* uranus */
+    1.28943695621391310e+01,
+    -1.51111514016986312e+01,
+    -2.23307578892655734e-01,
+    2.96460137564761618e-03 * days_per_year,
+    2.37847173959480950e-03 * days_per_year,
+    -2.96589568540237556e-05 * days_per_year,
+    4.36624404335156298e-05 * solar_mass
+  },
+  {                               /* neptune */
+    1.53796971148509165e+01,
+    -2.59193146099879641e+01,
+    1.79258772950371181e-01,
+    2.68067772490389322e-03 * days_per_year,
+    1.62824170038242295e-03 * days_per_year,
+    -9.51592254519715870e-05 * days_per_year,
+    5.15138902046611451e-05 * solar_mass
+  }
+};
+
+int main(int argc, char ** argv)
+{
+  int n = atoi(argv[1]);
+  int i;
+
+  offset_momentum(NBODIES, bodies);
+  printf ("%.9f\n", energy(NBODIES, bodies));
+  for (i = 1; i <= n; i++)
+    advance(NBODIES, bodies, 0.01);
+  printf ("%.9f\n", energy(NBODIES, bodies));
+  return 0;
+}

data/sources/gcc/nbody.gcc-3.gcc

@@ -0,0 +1,142 @@
+/*
+ * The Computer Language Benchmarks Game
+ * http://shootout.alioth.debian.org/
+ *
+ * Contributed by Christoph Bauer
+ * modified by Jorge Peixoto de Morais Neto
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <err.h>
+
+#define SOLAR_MASS (4 * M_PI * M_PI)
+
+/*power-of-two alignment helps when indexing arrays */
+struct __attribute__ ((aligned(64))) planet_t {
+    double x, y, z;
+    double vx, vy, vz;
+    double mass;
+};
+typedef struct planet_t planet_t;
+
+static void advance (planet_t *bodies, int nb, double dt) {
+    int i, j;
+    for (i = nb - 1; i >= 0; i--) 
+     	for (j = 0; j < i; j++) { 
+    	    double dx = bodies[i].x - bodies[j].x;
+     	    double dy = bodies[i].y - bodies[j].y;
+     	    double dz = bodies[i].z - bodies[j].z;
+     	    double distance = sqrt (dx * dx + dy * dy + dz * dz);
+     	    double mag = dt / (distance * distance * distance);
+     	    bodies[i].vx -= bodies[j].mass * mag * dx;
+     	    bodies[i].vy -= bodies[j].mass * mag * dy;
+     	    bodies[i].vz -= bodies[j].mass * mag * dz;
+     	    bodies[j].vy += bodies[i].mass * mag * dy;
+     	    bodies[j].vz += bodies[i].mass * mag * dz;
+     	    bodies[j].vx += bodies[i].mass * mag * dx;
+     	}
+
+    for (i = nb - 1; i >= 0; i--) { 
+     	bodies[i].x += dt * bodies[i].vx; 
+     	bodies[i].y += dt * bodies[i].vy; 
+     	bodies[i].z += dt * bodies[i].vz;
+    } 
+}
+
+static inline double energy (planet_t const *bodies, int nb) {
+    double e = 0.0;
+    int i, j; 
+    for (i = nb - 1; i >= 0; i--)
+     	e += bodies[i].mass *
+	    (bodies[i].vx * bodies[i].vx + bodies[i].vy * bodies[i].vy + bodies[i].vz * bodies[i].vz); 
+
+    e /= 2;
+    for (i = nb - 1; i >= 0; i--) 
+	for (j = 0; j < i; j++) {
+	    double dx = bodies[i].x - bodies[j].x;  
+      	    double dy = bodies[i].y - bodies[j].y;  
+      	    double dz = bodies[i].z - bodies[j].z;  
+      	    double distance = sqrt (dx * dx + dy * dy + dz * dz);  
+      	    e -= bodies[i].mass * bodies[j].mass / distance;  
+      	} 
+    return e;
+}
+
+static inline void offset_momentum (planet_t *bodies, int nb) {
+    double py = 0.0, pz = 0.0, px = 0.0;
+    int i;
+    for (i = nb - 1; i >= 0; i--) {
+	py += bodies[i].vy * bodies[i].mass;
+	pz += bodies[i].vz * bodies[i].mass;
+	px += bodies[i].vx * bodies[i].mass;
+    }
+    /*bodies[0] is the Sun*/
+    bodies[0].vx = -px / SOLAR_MASS;
+    bodies[0].vy = -py / SOLAR_MASS;
+    bodies[0].vz = -pz / SOLAR_MASS;
+}
+
+int main (int argc, char **argv) {
+#define NBODIES 5
+#define DAYS_PER_YEAR 365.24
+    static planet_t bodies[NBODIES] = {
+	{                               /* sun */
+	    0, 0, 0, 0, 0, 0, SOLAR_MASS
+	},
+	{                               /* jupiter */
+	    4.84143144246472090e+00,
+	    -1.16032004402742839e+00,
+	    -1.03622044471123109e-01,
+	    1.66007664274403694e-03 * DAYS_PER_YEAR,
+	    7.69901118419740425e-03 * DAYS_PER_YEAR,
+	    -6.90460016972063023e-05 * DAYS_PER_YEAR,
+	    9.54791938424326609e-04 * SOLAR_MASS
+	},
+	{                               /* saturn */
+	    8.34336671824457987e+00,
+	    4.12479856412430479e+00,
+	    -4.03523417114321381e-01,
+	    -2.76742510726862411e-03 * DAYS_PER_YEAR,
+	    4.99852801234917238e-03 * DAYS_PER_YEAR,
+	    2.30417297573763929e-05 * DAYS_PER_YEAR,
+	    2.85885980666130812e-04 * SOLAR_MASS
+	},
+	{                               /* uranus */
+	    1.28943695621391310e+01,
+	    -1.51111514016986312e+01,
+	    -2.23307578892655734e-01,
+	    2.96460137564761618e-03 * DAYS_PER_YEAR,
+	    2.37847173959480950e-03 * DAYS_PER_YEAR,
+	    -2.96589568540237556e-05 * DAYS_PER_YEAR,
+	    4.36624404335156298e-05 * SOLAR_MASS
+	},
+	{                               /* neptune */
+	    1.53796971148509165e+01,
+	    -2.59193146099879641e+01,
+	    1.79258772950371181e-01,
+	    2.68067772490389322e-03 * DAYS_PER_YEAR,
+	    1.62824170038242295e-03 * DAYS_PER_YEAR,
+	    -9.51592254519715870e-05 * DAYS_PER_YEAR,
+	    5.15138902046611451e-05 * SOLAR_MASS
+	}
+    };
+    long n = 1000;
+    if (argc >= 2) {
+	char *tail;
+	char const *arg = argv[1];
+	n = strtol (arg, &tail, 0);
+	if (tail == arg)
+	    errx (1, "Could no convert \"%s\" to a long integer", arg);
+    }
+
+    offset_momentum (bodies, NBODIES);
+    printf ("%.9f\n", energy (bodies, NBODIES));
+    long i;
+    for (i = n; i > 0; i--)
+	advance (bodies, NBODIES, 0.01);
+
+    printf ("%.9f\n", energy (bodies, NBODIES));
+    return 0;
+}