chrislo-sourceclassifier 0.2.0 → 0.2.1

data/sources/gcc/lists.gcc

@@ -1,226 +0,0 @@
-/* -*- mode: c -*-
- * $Id: lists.gcc,v 1.1.1.1 2004-05-19 18:10:23 bfulgham Exp $
- * http://www.bagley.org/~doug/shootout/
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#define SIZE 10000
-
-// a simple Double Linked List
-// the head node is special, it's val is length of list
-typedef struct DLL {
-    int val;
-    struct DLL *next;	/* points to next or head (if at tail) */
-    struct DLL *prev;	/* points to prev or tail (if at head) */
-} DLL;
-
-inline int list_length(DLL *head) { return(head->val); }
-inline int list_empty(DLL *head) { return(list_length(head) == 0); }
-inline DLL *list_first(DLL *head) { return(head->next); }
-inline DLL *list_last(DLL *head) { return(head->prev); }
-
-void list_push_tail(DLL *head, DLL *item) {
-    DLL *tail = head->prev;
-    tail->next = item;
-    item->next = head;
-    head->prev = item;
-    item->prev = tail;
-    head->val++;
-}
-
-DLL *list_pop_tail(DLL *head) {
-    DLL *prev, *tail;
-    if (list_empty(head)) return(NULL);
-    tail = head->prev;
-    prev = tail->prev;
-    prev->next = head;
-    head->prev = prev;
-    head->val--;
-    return(tail);
-}
-
-void list_push_head(DLL *head, DLL *item) {
-    DLL *next = head->next;
-    head->next = item;
-    next->prev = item;
-    item->next = next;
-    item->prev = head;
-    head->val++;
-}
-
-DLL *list_pop_head(DLL *head) {
-    DLL *next;
-    if (list_empty(head)) return(NULL);
-    next = head->next;
-    head->next = next->next;
-    next->next->prev = head;
-    head->val--;
-    return(next);
-}
-
-int list_equal(DLL *x, DLL *y) {
-    DLL *xp, *yp;
-    // first val's checked will be list lengths
-    for (xp=x, yp=y; xp->next != x; xp=xp->next, yp=yp->next) {
-	if (xp->val != yp->val) return(0);
-    }
-    if (xp->val != yp->val) return(0);
-    return(yp->next == y);
-}
-
-void list_print(char *msg, DLL *x) {
-    DLL *xp, *first = x->next;
-    int i = 0;
-    fputs(msg, stdout);
-    printf("length: %d\n", list_length(x));
-    for (xp=x->next; xp->next != first; xp=xp->next) {
-	printf("i:%3d  v:%3d  n:%3d  p:%3d\n", ++i,
-	       xp->val, xp->next->val, xp->prev->val);
-    }
-    printf("[last entry points to list head]\n");
-    printf("[val of next of tail is:  %d]\n", xp->next->val);
-}
-
-DLL *list_new() {
-    DLL *l = (DLL *)malloc(sizeof(DLL));
-    l->next = l;
-    l->prev = l;
-    l->val = 0;
-    return(l);
-}
-
-/* inclusive sequence 'from' <-> 'to' */
-DLL *list_sequence(int from, int to) {
-    int size, tmp, i, j;
-    DLL *l;
-    if (from > to) {
-	tmp = from; from = to; to = tmp;
-    }
-    size = to - from + 1;
-    l = (DLL *)malloc((size+1) * sizeof(DLL));
-    from--;
-    for (i=0, j=1; i<size; ++i, ++j) {
-	l[i].next = &l[i+1];
-	l[j].prev = &l[j-1];
-	l[i].val = from++;
-    }
-    l[0].prev = &l[size];
-    l[size].next = &l[0];
-    l[size].prev = &l[size-1];
-    l[size].val = from;
-    l[0].val = size;
-    return(l);
-}
-
-DLL *list_copy(DLL *x) {
-    int i, j, size = list_length(x);
-    DLL *xp, *l = (DLL *)malloc((size+1) * sizeof(DLL));
-    for (i=0, j=1, xp=x; i<size; i++, j++, xp=xp->next) {
-	l[i].next = &l[j];
-	l[j].prev = &l[i];
-	l[i].val = xp->val;
-    }
-    l[0].prev = &l[size];
-    l[size].next = &l[0];
-    l[size].val = list_last(x)->val;
-    return(l);
-}
-
-void list_reverse (DLL *head) {
-    DLL *tmp, *p = head;
-    do {
-	tmp = p->next;
-	p->next = p->prev;
-	p->prev = tmp;
-	p = tmp;
-    } while (p != head);
-}
-
-int test_lists() {
-    int len = 0;
-    // create a list of integers (li1) from 1 to SIZE
-    DLL *li1 = list_sequence(1, SIZE);
-    // copy the list to li2
-    DLL *li2 = list_copy(li1);
-    // remove each individual item from left side of li2 and
-    // append to right side of li3 (preserving order)
-    DLL *li3 = list_new();
-    // compare li2 and li1 for equality
-    if (!list_equal(li2, li1)) {
-	fprintf(stderr, "li2 and li1 are not equal\n");
-	exit(1);
-    }
-    while (!list_empty(li2)) {
-	list_push_tail(li3, list_pop_head(li2));
-    }
-    // li2 must now be empty
-    if (!list_empty(li2)) {
-	fprintf(stderr, "li2 should be empty now\n");
-	exit(1);
-    }
-    // remove each individual item from right side of li3 and
-    // append to right side of li2 (reversing list)
-    while (!list_empty(li3)) {
-	list_push_tail(li2, list_pop_tail(li3));
-    }
-    // li3 must now be empty
-    if (!list_empty(li3)) {
-	fprintf(stderr, "li3 should be empty now\n");
-	exit(1);
-    }
-    // reverse li1 in place
-    list_reverse(li1);
-    // check that li1's first item is now SIZE
-    if (list_first(li1)->val != SIZE) {
-	fprintf(stderr, "li1 first value wrong, wanted %d, got %d\n",
-		SIZE, list_first(li1)->val);
-	exit(1);
-    }
-    // check that li1's last item is now 1
-    if (list_last(li1)->val != 1) {
-	fprintf(stderr, "last value wrong, wanted %d, got %d\n",
-		SIZE, list_last(li1)->val);
-	exit(1);
-    }
-    // check that li2's first item is now SIZE
-    if (list_first(li2)->val != SIZE) {
-	fprintf(stderr, "li2 first value wrong, wanted %d, got %d\n",
-		SIZE, list_first(li2)->val);
-	exit(1);
-    }
-    // check that li2's last item is now 1
-    if (list_last(li2)->val != 1) {
-	fprintf(stderr, "last value wrong, wanted %d, got %d\n",
-		SIZE, list_last(li2)->val);
-	exit(1);
-    }
-    // check that li1's length is still SIZE
-    if (list_length(li1) != SIZE) {
-	fprintf(stderr, "li1 size wrong, wanted %d, got %d\n",
-		SIZE, list_length(li1));
-	exit(1);
-    }
-    // compare li1 and li2 for equality
-    if (!list_equal(li1, li2)) {
-	fprintf(stderr, "li1 and li2 are not equal\n");
-	exit(1);
-    }
-    len = list_length(li1);
-    free(li1);
-    free(li2);
-    free(li3);
-    // return the length of the list
-    return(len);
-}
-
-int main(int argc, char *argv[]) {
-    int n = ((argc == 2) ? atoi(argv[1]) : 1);
-    int result = 0;
-    while(n--) result = test_lists();
-    printf("%d\n", result);
-    return 0;
-}

data/sources/gcc/magicsquares.gcc

@@ -1,378 +0,0 @@
-/* The Computer Language Benchmarks Game
-   http://shootout.alioth.debian.org/
- 
-   contributed contributed by Charlie Brej
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-int n=0;
-int mn=0;
-
-typedef struct FfmCache {
-    int x;
-    int y;
-    int pm_count;
-    int pm[];
-    }FfmCache, *PtrFfmCache;
-
-typedef struct Square {
-    struct Square* next;
-    PtrFfmCache ffm;
-    int priority;
-    int *grid;
-    int *unused;
-    }Square, *PtrSquare;
-
-
-  
-void SquarePrint(PtrSquare square)
-{
-    int x;
-    int y;
-    for (y=0; y<n; y++){
-        for (x=0; x<n; x++){
-            printf("%d ", square->grid[x+y*n]);
-            }
-        printf("\n");
-        }
-    return;
-}
-
-
-    
-PtrSquare SquareNew(void)
-{
-    PtrSquare new_square = malloc(sizeof(Square));
-    new_square->grid = malloc(n * n * sizeof(int));
-    new_square->unused = malloc(n * n * sizeof(int));
-    new_square->next=NULL;
-    new_square->ffm=NULL;
-    new_square->priority=0;
-    return new_square;
-}
-
-PtrSquare SquareNewEmpty(void)
-{
-    int i;
-    PtrSquare new_square = SquareNew();
-    for (i=0; i<n*n; i++){
-        new_square->grid[i]=0;
-        new_square->unused[i]=1;
-        }
-    return new_square;
-}
-
-
-PtrSquare SquareNewCopy(PtrSquare old_square)
-{
-    int i;
-    PtrSquare new_square = SquareNew();
-    for (i=0; i<n*n; i++){
-        new_square->grid[i]=old_square->grid[i];
-        new_square->unused[i]=old_square->unused[i];
-        }
-    return new_square;
-}
-    
-void SquareFree(PtrSquare square)
-{
-    free(square->ffm);
-    free(square->unused);
-    free(square);
-    return ;
-}
-   
-void SquareGetRow(PtrSquare square, int row, int* out_array)
-{
- int i;
- for (i=0; i<n; i++){
-    out_array[i] = square->grid[row*n+i];
-    }
-}
-    
-void SquareGetColumn(PtrSquare square, int column, int* out_array)
-{
- int i;
- for (i=0; i<n; i++){
-    out_array[i] = square->grid[n*i+column];
-    }
-}
-    
-int IntArraySum(int* data)
-{
- int i;
- int sum = 0;
- for (i=0; i<n; i++){
-    sum += data[i];
-    }
- return sum;
-}
-
-int IntArrayCount0s(int* data)
-{
- int i;
- int count = 0;
- for (i=0; i<n; i++)
-    if(data[i]==0)
-        count++;
- return count;
-}
-
-int SquareNumberPresent(PtrSquare square, int number)
-{
-    int i;
-    for (i=0; i<n*n; i++){
-        if (square->grid[i] == number) return 1;
-        }
-    return 0;
-}
-
-int SquareEmptyCount(PtrSquare square)
-{
-    int i;
-    int count=0;
-    for (i=0; i<n*n; i++){
-        if (square->grid[i] == 0) count++;
-        }
-    return count;
-}
-
-void SquareGetPossibleMoves(PtrSquare square, int x, int y, int* ret_pm, int* ret_pm_count)
-{
-    int cell_groups[4][n];
-    int cell_group_count=2;
-    int group;
-    int i, i2;
-    int cur_acc;
-    int highest_candidate = n*n;
-    int lowest_candidate = 1;
-    
-    int one_possible = 0;
-    
-    
-    SquareGetRow(square, y, cell_groups[0]);
-    SquareGetColumn(square, x, cell_groups[1]);
-    
-    *ret_pm_count = 0;
-    if (x==y) {
-        for (i=0; i<n; i++)
-            cell_groups[cell_group_count][i] = square->grid[n*i+i];
-        cell_group_count++;
-        }
-    if (x + y == n - 1) {
-        for (i=0; i<n; i++)
-            cell_groups[cell_group_count][i] = square->grid[i + (n - 1 - i) * n];
-        cell_group_count++;
-        }
-    
-    for (group=0; group<cell_group_count; group++){
-        int count = 0;
-        for (i=0; i<n; i++){
-            if (cell_groups[group][i] == 0){
-                if (count++) break;
-                }
-            }
-        if (count==1){
-            int new_one_possible = mn - IntArraySum(cell_groups[group]);
-            if (one_possible==0){
-                one_possible = new_one_possible;
-                if (one_possible<1 || one_possible>n*n || SquareNumberPresent(square, one_possible)) return;
-                }
-            if (one_possible != new_one_possible) return;
-            }
-        }
-    if (one_possible){
-        ret_pm[0] = one_possible;
-        *ret_pm_count = 1;
-        return;
-        }
-    
-    
-    int local_pm_count = 0;
-    int zeros[cell_group_count];
-    int highest_zero_count=0;
-    for (i=0; i<cell_group_count; i++){
-        int zero_count = IntArrayCount0s(cell_groups[i])-1;
-        zeros[i] = zero_count;
-        if (highest_zero_count < zero_count) highest_zero_count = zero_count;
-        }
-    
-    int lows[highest_zero_count];
-    int higs[highest_zero_count];
-    
-    i2=0;
-    cur_acc=0;
-    for (i=0; i2<highest_zero_count; i++){
-        if(square->unused[i]){
-            cur_acc+=(i+1);
-            lows[i2]=cur_acc;
-            i2++;
-            }
-        }
-    
-    i2=0;
-    cur_acc=0;
-    for (i=n*n-1; i2<highest_zero_count; i--){
-        if(square->unused[i]){
-            cur_acc+=(i+1);
-            higs[i2]=cur_acc;
-            i2++;
-            }
-        }
-    
-    for (group=0; group<cell_group_count; group++){
-        int lft = mn - IntArraySum(cell_groups[group]);
-        int k = zeros[group];
-        int temp_highest_candidate = lft - lows[k-1];
-        int temp_lowest_candidate = lft - higs[k-1];
-        if (temp_highest_candidate<highest_candidate) highest_candidate = temp_highest_candidate;
-        if (temp_lowest_candidate>lowest_candidate)   lowest_candidate =  temp_lowest_candidate;
-        }
-    
-    for (i=lowest_candidate; i<=highest_candidate; i++){
-        if(square->unused[i-1]){
-            ret_pm[local_pm_count++]=i;
-            
-            }
-            
-        }
-    
-        
-    *ret_pm_count = local_pm_count;
-    return;
-    
-    
-}
-
-
-PtrFfmCache SquareGetFewestMoves(PtrSquare square)
-{
-    int x,y;
-    int i;
-    if (square->ffm){
-        return square->ffm;
-        }
-    square->ffm = malloc(sizeof(FfmCache)+sizeof(int)*n*n);
-    square->ffm->pm_count=n*n+1;
-    
-    for (y=0; y<n; y++)
-        for (x=0; x<n; x++){
-            int index = x + y * n;
-            if (square->grid[index] == 0){
-                int temp_list[n*n];
-                int temp_list_count;
-                SquareGetPossibleMoves(square,x,y,temp_list,&temp_list_count);
-                if (temp_list_count<square->ffm->pm_count){
-                    square->ffm->pm_count = temp_list_count;
-                    square->ffm->x = x;
-                    square->ffm->y = y;
-                    for (i=0; i<square->ffm->pm_count; i++) square->ffm->pm[i] = temp_list[i];
-                    }
-                }
-            }
-    
-    
-    if (square->ffm->pm_count>n*n) square->ffm->pm_count=0;
-    return square->ffm;
-    
-    
-}
-
-   
-int SquareGetPriority(PtrSquare square)
-{
-    int priority;
-    if (square->priority) return square->priority;
-    PtrFfmCache ffm = SquareGetFewestMoves(square);
-    priority = ffm->pm_count + SquareEmptyCount(square);
-    square->priority = priority;
-    return priority;
-}
-
-int SquareCompare(PtrSquare square1, PtrSquare square2)
-{
- int c = SquareGetPriority(square1) - SquareGetPriority(square2);
- if (c==0){
-    int i;
-    for (i=0; c==0 && i<n*n; i++){
-        c = square1->grid[i] - square2->grid[i];
-        }
-    }
- return c;
-}
-
-PtrSquare SquareQueueMerge(PtrSquare queue1, PtrSquare queue2)
-{
-    if (!queue1) return queue2;
-    if (!queue2) return queue1;
-    
-    PtrSquare new_queue = NULL;
-    PtrSquare* cur_ptr = &new_queue;
-    
-    while (1){
-        if (SquareCompare(queue1, queue2)<0){
-            *cur_ptr = queue1;
-            cur_ptr = &queue1->next;
-            queue1 = queue1->next;
-            if (!queue1){
-                *cur_ptr = queue2;
-                return new_queue;
-                }
-            }
-        else {
-            *cur_ptr = queue2;
-            cur_ptr = &queue2->next;
-            queue2 = queue2->next;
-            if (!queue2){
-                *cur_ptr = queue1;
-                return new_queue;
-                }
-            }
-        }
-}
-
-PtrSquare SquareGetSuccessorNodes(PtrSquare square)
-{
-    int i;
-    PtrSquare square_queue = NULL;
-    PtrFfmCache ffm = SquareGetFewestMoves(square);
-    
-    for (i=0; i<ffm->pm_count; i++){
-        PtrSquare new_square = SquareNewCopy(square);
-        new_square->grid[ffm->x+ffm->y*n] = ffm->pm[i];
-        new_square->unused[ffm->pm[i]-1]=0;
-        square_queue = SquareQueueMerge(square_queue, new_square);
-        }
-    return square_queue;
-}
-
-
-
-int main(int argc, char **argv)
-{
-   
-    if (argv[1]) n = atoi(argv[1]);
-    else         n = 5;
-    mn = n * (1 + n * n) / 2;
-    
-    PtrSquare queue = SquareNewEmpty();
-    PtrSquare cur_square;
-    
-    while (queue){
-        cur_square = queue;
-        queue = queue->next;
-        
-        int priority = SquareGetPriority(cur_square);
-        if (!priority) break;
-        
-        
-        PtrSquare successor_nodes = SquareGetSuccessorNodes(cur_square);
-        queue = SquareQueueMerge(queue, successor_nodes);
-        SquareFree(cur_square);
-        }
-    
-    SquarePrint(cur_square);
-    return 0;
-}