+{
+ int i, j, n = -1;
+
+ if (programs) {
+
+ /* look for program */
+ for (i = 0; i < nb_programs; i++) {
+ if ((programs + i)->id == id) {
+ n = i;
+ break;
+ }
+ }
+ }
+ if (n == -1) {
+ VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
+ return;
+ }
+
+ /* clean program */
+ if ((programs + n)->storage) {
+ free ((programs + n)->storage);
+ }
+ if ((programs + n)->stack) {
+ free ((programs + n)->stack);
+ }
+ if ((programs + n)->root) {
+ delelement ((programs + n)->root);
+ }
+ if ((programs + n)->string) {
+ free ((programs + n)->string);
+ }
+
+ /* remove entry */
+ workspace_t *tmp = (workspace_t *) callocordie (nb_programs - 1, sizeof (workspace_t));
+ for (i = 0, j = 0; i < nb_programs; i++) {
+ if (i != n) {
+ memcpy (tmp + j, programs + i, sizeof (workspace_t));
+ j++;
+ }
+ }
+ free (programs);
+ programs = tmp;
+ nb_programs--;
+}
+
+/* stack management */
+
+double get (int n)
+{
+ double ret = 0;
+ if ((n <= 0) || (n > stack_size)) {
+ VERBOSE (WARNING, fprintf (stdout, "error out of bound (%d/%d)\n", n, stack_size));
+ } else {
+ ret = stack[n - 1];
+ }
+ return ret;
+}
+
+double length ()
+{
+ return stack_size;
+}
+
+double pop ()
+{
+ double ret = 0;
+ if (stack_size > 0) {
+ ret = stack[--stack_size];
+ double *tmp = (double *) callocordie (stack_size, sizeof (double));
+ memcpy (tmp, stack, stack_size * sizeof (double));
+ free (stack);
+ stack = tmp;
+ } else {
+ VERBOSE (WARNING, fprintf (stdout, "error stack empty\n"));
+ }
+ return ret;
+}
+
+double push (double val)
+{
+ double *tmp = (double *) callocordie (stack_size + 1, sizeof (double));
+ memcpy (tmp, stack, stack_size * sizeof (double));
+ if (stack) {
+ free (stack);
+ }
+ stack = tmp;
+ stack[stack_size++] = val;
+ return val;
+}
+
+double put (int n, double val)
+{
+ if (n <= 0) {
+ VERBOSE (WARNING, fprintf (stdout, "error out of bound (%d/%d)\n", n, stack_size));
+ return 0;
+ }
+ if (n > stack_size) {
+ double *tmp = (double *) callocordie (n, sizeof (double));
+ memcpy (tmp, stack, stack_size * sizeof (double));
+ free (stack);
+ stack = tmp;
+ stack_size = n;
+ }
+ stack[n - 1] = val;
+ return val;
+}
+
+double set (int nbops, element_t **ops)
+{
+ int i;
+ if (stack) {
+ free (stack);
+ }
+ stack = NULL;
+ stack_size = 0;
+ if (nbops != 0) {
+ stack = (double *) callocordie (nbops, sizeof (double));
+ for (i = 0; i < nbops; i++) {
+ stack[i] = evaluate_element (ops[i], 0);
+ }
+ stack_size = nbops;
+ }
+ return stack_size;
+}
+
+void show (void)
+{
+ int i;
+ fprintf (stdout, "stack:");
+ for (i = 0; i < stack_size; i++) {
+ fprintf (stdout, " ");
+ fprintf (stdout, minform, stack[i]);
+ }
+ fprintf (stdout, "\n");
+}
+
+/* stack functions */
+
+double max ()
+{
+ double ret = 0;
+ int i;
+ if (stack_size < 1) {
+ VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+ return 0;
+ }
+ ret = stack[0];
+ for (i = 1; i < stack_size; i++) {
+ if (stack[i] > ret) {
+ ret = stack[i];
+ }
+ }
+ return ret;
+}
+
+double mean ()
+{
+ double ret = 0;
+ int i;
+ if (stack_size < 1) {
+ VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+ return 0;
+ }
+ for (i = 0; i < stack_size; i++) {
+ ret += stack[i];
+ }
+ return ret / stack_size;
+}
+
+double min ()
+{
+ double ret = 0;
+ int i;
+ if (stack_size < 1) {
+ VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+ return 0;
+ }
+ ret = stack[0];
+ for (i = 1; i < stack_size; i++) {
+ if (stack[i] < ret) {
+ ret = stack[i];
+ }
+ }
+ return ret;
+}
+
+void order ()
+{
+ int i, j;
+ if (stack_size < 1) {
+ VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+ return;
+ }
+ for (i = 0; i < stack_size - 1; i++) {
+ int done = 0;
+ for (j = 0; j < stack_size - 1; j++) {
+ if (stack[j] > stack[j + 1]) {
+ double tmp = stack[j];
+ stack[j] = stack[j + 1];
+ stack[j + 1] = tmp;
+ done = 1;
+ }
+ }
+ if (done == 0) {
+ break;
+ }
+ }
+}
+
+double median ()
+{
+ double ret = 0;
+ if (stack_size < 3) {
+ VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+ return 0;
+ }
+ double *tmp = (double *) callocordie (stack_size, sizeof (double));
+ memcpy (tmp, stack, stack_size * sizeof (double));
+ order ();
+ ret = stack[(stack_size - 1)/ 2];
+ memcpy (stack, tmp, stack_size * sizeof (double));
+ free (tmp);
+ return ret;
+}
+
+double prod ()
+{
+ double ret = 1;
+ int i;
+ if (stack_size < 1) {
+ VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+ return 0;
+ }
+ for (i = 0; i < stack_size; i++) {
+ ret *= stack[i];
+ }
+ return ret;
+}
+
+double sum ()
+{
+ double ret = 0;
+ int i;
+ if (stack_size < 1) {
+ VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+ return 0;
+ }
+ for (i = 0; i < stack_size; i++) {
+ ret += stack[i];
+ }
+ return ret;
+}
+
+double variance ()
+{
+ double ret = 0;
+ double m = 0;
+ int i;
+ if (stack_size < 2) {
+ VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+ return 0;
+ }
+ m = mean ();
+ for (i = 0; i < stack_size; i++) {
+ ret += (stack[i] - m) * (stack[i] - m);
+ }
+ return ret / stack_size;
+}
+