int storage_size = -1;
double *storage = NULL;
+int argument_size = 0;
+double *argument = NULL;
+
int stack_size = 0;
double *stack = NULL;
{ "|", Or, 2, 1, -2}
};
-#define NB_FUNCTIONS 41
+#define NB_FUNCTIONS 50
keyword_t functions[NB_FUNCTIONS] = {
{ "sqrt", Sqr, 1, 4, 5},
{ "pow", Pow, 2, 3, 5},
{ "inc", Inc, 1, 3, 5},
{ "dec", Dec, 1, 3, 5},
{ "disp", Disp, 0, 4, 9},
- { "mem", Mem, 1, 3, 9},
+ { "mem", Mem, 1, 3, 5},
{ "clr", Clear, 0, 3, 9},
{ "quit", Quit, 0, 4, 9},
{ "help", Help, 0, 4, 9},
{ "cond", Cond, 3, 4, 5},
{ "while", While, 2, 5, 5},
{ "print", Print, 1, 5, 5},
- { "prog", Prog, 3, 4, 9},
+ { "prog", Prog, 2, 4, 9},
+ { "arg", Arg, 1, 3, 5},
{ "call", Call, MAX_ARGS, 4, 5},
{ "ls", List, 0, 2, 9},
{ "edit", Edit, 1, 4, 9},
{ "push", Push, 1, 4, 5},
{ "put", Put, 2, 3, 5},
{ "set", Set, MAX_ARGS, 3, 5},
- { "show", Show, 0, 4, 5},
+ { "show", Show, 0, 4, 5},
+ { "max", Max, 2, 3, 5},
+ { "mean", Mean, 2, 4, 5},
+ { "med", Median, 0, 3, 5},
+ { "min", Min, 2, 3, 5},
+ { "ord", Order, 0, 3, 5},
+ { "prod", Prod, 0, 4, 5},
+ { "sum", Sum, 0, 3, 5},
+ { "var", Variance, 2, 3, 5},
};
#define NB_CONSTANTS 3
delelement (root);
return ERROR_OP;
}
- element_t *newprog = newelement (Code, root->nbops + 1, 5);
+ element_t *newcode = newelement (Code, root->nbops + 1, 5);
for (i = 0; i < root->nbops; i++) {
- newprog->ops[i] = root->ops[i];
+ newcode->ops[i] = root->ops[i];
root->ops[i] = NULL;
}
- newprog->ops[root->nbops] = new;
+ newcode->ops[root->nbops] = new;
delelement (root);
- root = newprog;
+ root = newcode;
} while (*str == ',');
if (*str != '}') {
keyword_t *operator = operators + i;
if (codecmp (operator->keyword, str) == 0) {
VERBOSE (DEBUG, fprintf (stdout, "start processing operator\n"));
- if (root) {
+ if ((root) && (root->prio == 9)) {
+ VERBOSE (DEBUG, fprintf (stdout, "terminal function (%d)\n", root->func));
+ delelement (root);
+ return ERROR_OP;
+ } else if (root) {
if ((prio) && (prio > operator->prio)) {
VERBOSE (DEBUG, fprintf (stdout, "stop because operator priority\n"));
*next = str;
return ERROR_OP;
}
} else if (*str == '-') {
- root = newelement (Sig, 1, 9);
+ root = newelement (Sig, 1, 6);
} else {
return ERROR_OP;
}
case Code: func = "Code"; break;
case Print: func = "Print"; break;
case Prog: func = "Program"; break;
+ case Arg: func = "Argument"; break;
case Call: func = "Call"; break;
case List: func = "List"; break;
case Edit: func = "Edit"; break;
case Put: func = "Put"; break;
case Set: func = "Set"; break;
case Show: func = "Show"; break;
+ case Max: func = "Maximum"; break;
+ case Mean: func = "Mean"; break;
+ case Median: func = "Median"; break;
+ case Min: func = "Minimum"; break;
+ case Order: func = "Order"; break;
+ case Prod: func = "Product"; break;
+ case Sum: func = "Sum"; break;
+ case Variance: func = "Variance"; break;
}
fprintf (stdout, "Function: %s\n", func);
/* program function */
-void prog (int id, int nbmems, element_t *root)
+void prog (int id, element_t *root)
{
int i, n = -1;
/* set program */
(programs + n)->id = id;
(programs + n)->answer = 0;
- (programs + n)->storage = (double *) callocordie (nbmems, sizeof (double));
- (programs + n)->storage_size = nbmems;
+ (programs + n)->storage = NULL;
+ (programs + n)->storage_size = 0;
(programs + n)->stack = NULL;
(programs + n)->stack_size = 0;
(programs + n)->root = dupelement (root);
}
-double call (int id, int nbops, element_t **ops)
+double arg (int id)
+{
+ double ret = 0;
+ if ((id <= 0) || (id > argument_size)) {
+ VERBOSE (WARNING, fprintf (stdout, "error out of bound (%d/%d)\n", id, argument_size));
+ } else {
+ ret = argument[id - 1];
+ }
+ return ret;
+}
+
+double call (int id, int nbargs, element_t **args)
{
workspace_t tmp = {0};
- int i, n = -1;
+ int i, l, n = -1;
double ret = 0;
if (programs) {
/* store context */
tmp.answer = answer;
+ tmp.argument = argument;
+ tmp.argument_size = argument_size;
tmp.storage = storage;
tmp.storage_size = storage_size;
tmp.stack = stack;
answer = 0;
storage = (programs + n)->storage;
storage_size = (programs + n)->storage_size;
+ argument = NULL;
+ argument_size = 0;
stack = (programs + n)->stack;
stack_size = (programs + n)->stack_size;
- if (nbops > storage_size) {
- double *tmp = (double *) callocordie (nbops, sizeof (double));
- memcpy (tmp, storage, storage_size * sizeof (double));
- free (storage);
- (programs + n)->storage = storage = tmp;
- (programs + n)->storage_size = storage_size = nbops;
- }
- for (i = 0; i < nbops; i++) {
- double val = evaluate_element (ops[i], 0);
- store (i + 1, val);
+ if (nbargs > 0) {
+ argument = (double *) callocordie (nbargs, sizeof (double));
+ for (i = 0, l = 0; i < nbargs; l++) {
+ if (args[l]) {
+ argument[i++] = evaluate_element (args[l], 0);
+ }
+ }
+ argument_size = nbargs;
}
/* evaluate program */
(programs + n)->answer = answer;
(programs + n)->storage = storage;
(programs + n)->storage_size = storage_size;
+ if (argument) {
+ free (argument);
+ }
(programs + n)->stack = stack;
(programs + n)->stack_size = stack_size;
answer = tmp.answer;
storage = tmp.storage;
storage_size = tmp.storage_size;
+ argument = tmp.argument;
+ argument_size = tmp.argument_size;
stack = tmp.stack;
stack_size = tmp.stack_size;
// free ((programs + n)->string);
//}
- (programs + n)->string = strdup (string);
+ if (string) {
+ (programs + n)->string = strdup (string);
+ }
}
void del (int id)
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;
+}
+
+
/* help message */
void help (void)
fprintf (stdout, "control flow prim.:");
fprintf (stdout, " cond print while {} ;\n");
fprintf (stdout, "program management:");
- fprintf (stdout, " call del edit ls prog\n");
+ fprintf (stdout, " arg call del edit ls prog\n");
fprintf (stdout, "stack management:");
fprintf (stdout, " get len pop push put set show\n");
+ fprintf (stdout, "stack func.:");
+ fprintf (stdout, " max mean med min ord prod sum var\n");
fprintf (stdout, "control management:");
fprintf (stdout, " help quit\n");
fprintf (stdout, "constants:");
case Lt:
case And:
case Or:
- case Prog:
if (root->ops[1]) {
op1 = evaluate_element (root->ops[1], nextmask);
} else if (root->func != Store) {
case Not:
case Mem:
case Cond:
+ case Prog:
+ case Arg:
case Call:
case Edit:
case Del:
case Pop:
case Set:
case Show:
+ case Median:
+ case Order:
+ case Prod:
+ case Sum:
break;
case While:
if (root->ops[0] == NULL) {
}
op1 = (root->ops[1]) ? evaluate_element (root->ops[1], 0) : answer;
break;
+ case Max:
+ case Mean:
+ case Min:
+ case Variance:
+ if (root->ops[0]) {
+ op0 = evaluate_element (root->ops[0], 0);
+ op1 = (root->ops[1]) ? evaluate_element (root->ops[1], 0) : answer;
+ }
}
switch (root->func) {
case Code: return execute_code (root->ops, root->nbops);
case Print: return print (op0);
case Prog:
- prog ((int)op0, (int)op1, root->ops[2]);
+ prog ((int)op0, root->ops[1]);
savestring ((int)op0, root->string);
break;
+ case Arg: return arg ((int)op0);
case Call:
for (i = 1, nb =0; i < root->nbops; i++) {
if (root->ops[i]) {
}
return set (nb, root->ops);
case Show: show (); break;
+ case Max:
+ if (root->ops[0]) {
+ return op0 > op1 ? op0 : op1;
+ }
+ return max ();
+ case Mean:
+ if (root->ops[0]) {
+ return (op0 + op1) / 2;
+ }
+ return mean ();
+ case Median: return median ();
+ case Min:
+ if (root->ops[0]) {
+ return op0 < op1 ? op0 : op1;
+ }
+ return min ();
+ case Order: order (); break;
+ case Prod: return prod ();
+ case Sum: return sum ();
+ case Variance:
+ if (root->ops[0]) {
+ double m = (op0 + op1) / 2;
+ op0 -= m;
+ op1 -= m;
+ return op0 * op0 + op1 * op1;
+ }
+ return variance ();
}
return 0;
Soft'N'Design Software / projects / calc.git / blobdiff