fix bracket evaluation

[calc.git] / stack.c

#include <math.h>
#include <stdio.h>

#include "debug.h"
#include "format.h"
#include "parser.h"
#include "tabular.h"

#include "stack.h"

/* global variables */

tab_t * stack = NULL;

/* stack management */

double get (int n)
{
    return get_tab (stack, n);
}

double length ()
{
    return size_tab (stack);
}

double pop ()
{
    return pop_tab (stack, -1);
}

double push (double val)
{
    double ret = NAN;
    if (stack) {
        ret = push_tab (stack, -1, val);
    } else {
        stack = resize_tab (stack, 1);
        ret = set_tab (stack, 1, val);
    }
    return ret;
}

double put (int n, double val)
{
    if (n > size_tab (stack)) {
        stack = resize_tab (stack, n);
    }
    return set_tab (stack, n, val);
}

double set (int nbops, element_t **ops)
{
    int i;
    stack = resize_tab (stack, nbops);
    for (i = 0; i < nbops; i++) {
        set_tab (stack, i + 1, evaluate_element (ops[i], 0));
    }
    return size_tab (stack);
}

void show (void)
{
    int i, n = size_tab (stack);
    printf ("stack:");
    for (i = 0; i < n; i++) {
        printf (" ");
        printl (get_tab (stack, i + 1));
    }
    printf ("\n");
}

/* stack functions */

double max ()
{
    double ret = 0;
    int i, n = size_tab (stack);
    if (n < 1) {
        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", n));
        return 0;
    }
    ret = get_tab (stack, 1);
    for (i = 1; i < n; i++) {
        double cur = get_tab (stack, i + 1);
        if (cur > ret) {
            ret = cur;
        }
    }
    return ret;
}

double mean ()
{
    double ret = 0;
    int i, n = size_tab (stack);
    if (n < 1) {
        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", n));
        return 0;
    }
    for (i = 0; i < n; i++) {
        ret += get_tab (stack, i + 1);
    }
    return ret / n;
}

double min ()
{
    double ret = 0;
    int i, n = size_tab (stack);
    if (n < 1) {
        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", n));
        return 0;
    }
    ret = get_tab (stack, 1);
    for (i = 1; i < n; i++) {
        double cur = get_tab (stack, i + 1);
        if (cur < ret) {
            ret = cur;
        }
    }
    return ret;
}

void order ()
{
    order_tab (stack);
}

double median ()
{
    double ret = 0;
    int n = size_tab (stack);
    if (n < 3) {
        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", n));
    } else {
        tab_t *tmp = copy_tab (stack);
        order_tab (tmp);
        ret = get_tab (tmp, (n - 1) / 2 + 1);
        free_tab (tmp);
    }
    return ret;
}

double prod ()
{
    double ret = 1;
    int i, n = size_tab (stack);
    if (n < 1) {
        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", n));
        return 0;
    }
    for (i = 0; i < n; i++) {
        ret *= get_tab (stack, i + 1);
    }
    return ret;
}

double sum ()
{
    double ret = 0;
    int i, n = size_tab (stack);
    if (n < 1) {
        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", n));
        return 0;
    }
    for (i = 0; i < n; i++) {
        ret += get_tab (stack, i + 1);
    }
    return ret;
}

double variance ()
{
    double ret = 0;
    int i, n = size_tab (stack);
    if (n < 2) {
        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", n));
        return 0;
    }
    double m = mean ();
    for (i = 0; i < n; i++) {
        double x = get_tab (stack, i + 1);
        ret += (x - m) * (x - m);
    }
    return ret / n;
}

/* vim: set ts=4 sw=4 et: */