PSP0 llist

/**
@file
@brief Mean and standard deviation calculator

This program calculates the mean and (population) standard deviation, of a
sequence of real numbers, input to the program through stdin. The program
accepts comma and newline separated values.

As per the specification, the program accepts input from a file - simply pipe
the file into the program's stdin.

The specification suggested a linked list - a huge overengineering of this
trivial problem. Luckily the specification also allowed "variables" and "other
data structure(s)" to hold the data. I took that option and used stack'd
variables to hold the data - as only the data from the nth element is relavant
to the calculation.

@author Jake Sebastian-Jones
*/
#include<stdio.h>
#include<math.h>

/**
Linked list with queue and stack operations.

Written by Jake Sebastian-Jones
jake.sebastian-jones@linux.com
Released under the WTFPL
*/


#include<stdlib.h>

struct ll_node {
    struct ll_node *prev;
    struct ll_node *next;
    void *value;
};

struct llist{
    struct ll_node *head;
    struct ll_node *tail;
    int len;
};

inline static void ll_node_init(struct ll_node *n) {
    n->prev = NULL;
    n->next = NULL;
    n->value = NULL;
}

inline static void llist_init(struct llist *l) {
    l->head = NULL;
    l->tail = NULL;
    l->len = 0;
};

inline static void llist_enqueue(struct llist *l, struct ll_node *n) {
    if(l->head == NULL) {
        l->head = n;
        l->tail = n;
        l->len++;
    }
    else {
        l->tail->next = n;
        n->prev = l->tail;
        l->tail = n;
    }
};

inline static void llist_append(struct llist *l, struct ll_node *n) {
    llist_enqueue(l, n);
}

inline static void llist_push(struct llist *l, struct ll_node *n) {
    llist_enqueue(l, n);
}

inline static struct ll_node* llist_dequeue(struct llist *l) {
    struct ll_node *node = l->head;
    if(l->head == l->tail) {
        l->head = l->tail = NULL;
    }
    else if(l->head != NULL) {
        l->head = l->head->next;
    }
    return node;
}

inline static struct ll_node* llist_pop(struct llist *l) {
    struct ll_node *node = l->tail;
    if(l->head == l->tail) {
        l->head = l->tail = NULL;
    }
    else if(l->tail != NULL) {
        l->tail = l->tail->prev;
        l->tail->next = NULL;
    }
    return node;
}

inline static void ll_freelinks(struct llist *l) {
    while(l->head != NULL) {
        struct ll_node *node = llist_pop(l);
        free(node);
    }
}

inline static void append_list(struct llist *from, struct llist *to) {

    struct ll_node *node = from->head;
    while(node != NULL) {
        struct ll_node *next = malloc(sizeof(*next));
        ll_node_init(next);
        next->value = node->value;
        llist_append(to, next);
        node = node->next;
    }

}




int main(void) {
    double x, n, s2, sum, mean;

    fscanf(stdin, "%lf", &x);
    sum = mean = x;
    n = 1.0;

    struct llist list;
    llist_init(&list);

    while( fscanf(stdin, "%lf", &x) == 1) {
        sum += x;
        n++;

        s2 = ( (n-2.0) / (n-1.0) * s2)  + ( 1.0 / n) * pow(x - mean, 2.0);

        struct ll_node node;
        ll_node_init(&node);
        node.value = malloc(4);
        *((int*)(node.value)) = x;
        llist_push(&list, &node);

        mean = sum / n;
    }

    printf("mean = %.2lf\nσ = %.2lf\n", mean, sqrt(s2));
}