/* SGPC: Simple Genetic Programming in C (c) 1993 by Walter Alden Tackett and Aviram Carmi This code and documentation is copyrighted and is not in the public domain. All rights reserved. - This notice may not be removed or altered. - You may not try to make money by distributing the package or by using the process that the code creates. - You may not distribute modified versions without clearly documenting your changes and notifying the principal author. - The origin of this software must not be misrepresented, either by explicit claim or by omission. Since few users ever read sources, credits must appear in the documentation. - Altered versions must be plainly marked as such, and must not be misrepresented as being the original software. Since few users ever read sources, credits must appear in the documentation. - The authors are not responsible for the consequences of use of this software, no matter how awful, even if they arise from flaws in it. If you make changes to the code, or have suggestions for changes, let us know! (gpc@ipld01.hac.com) */ #ifndef lint static char treeops_c_rcsid[]="$Id: treeops.c,v 2.7 1993/04/22 07:39:12 gpc-avc Exp gpc-avc $"; #endif /* * * $Log: treeops.c,v $ * Revision 2.7 1993/04/22 07:39:12 gpc-avc * Removed old log messages * * Revision 2.6 1993/04/14 04:42:52 gpc-avc * Fixed side effect of read_tree() modifying the random seed. * replaced global references to POP by the arg pop * * */ #include #include #include #include "gpc.h" #ifdef ANSI_FUNC tree *create_tree_node( int pop, int nodetype, int id ) #else tree *create_tree_node(pop, nodetype, id) int pop; int nodetype; int id; #endif { tree *t; if ((t = (tree *) malloc(sizeof(tree))) == NULL) { perror(" at point 1 in create_tree_node() "); exit(errno); } t->nodetype = nodetype; t->id = id; t->pop = pop; switch (nodetype) { case FUNCTION: init_function(t); break; case TERMINAL: init_terminal(t); break; default: fprintf(stderr, "nodetype %d must be %d or %d in create_tree_node() \n", nodetype, FUNCTION, TERMINAL); } return t; } #ifdef ANSI_FUNC VOID init_function( tree *t ) #else VOID init_function(t) tree *t; #endif { pop_struct *pop = POP; if ((t->id < 0) || (t->id >= pop[t->pop].function_table_size)) { fprintf(stderr, "id %d must be >= 0 and < %d in init_function() \n", t->id, pop[t->pop].function_table_size); } if ((t->type.func = (function *) malloc(sizeof(function))) == NULL) { perror(" at point 1 in init_function() "); exit(errno); } if ((t->type.func->arg = (tree **) malloc(function_arity(t) * sizeof(tree *))) == NULL) { perror(" at point 2 in init_function() "); exit(errno); } if ((t->type.func->argvals = (GENERIC *) malloc(function_arity(t) * sizeof(GENERIC))) == NULL) { perror(" at point 3 in init_function() "); exit(errno); } } #ifdef ANSI_FUNC VOID init_terminal( tree *t ) #else VOID init_terminal(t) tree *t; #endif { pop_struct *pop = POP; GENERIC junk = -999999; /* t->id == terminal_table_size indicates that this terminal is a constant rather than a variable */ if ((t->id < 0) || (t->id > pop[t->pop].terminal_table_size)) { fprintf(stderr, "id %d must be >= 0 and <= %d in init_terminal() \n", t->id, pop[t->pop].terminal_table_size); } if ((t->type.term = (terminal *) malloc(sizeof(terminal))) == NULL) { perror(" at point 1 in init_terminal() "); exit(errno); } if (terminal_is_constant(t)) { if ((t->type.term->valptr = (GENERIC *) malloc(sizeof(GENERIC))) == NULL) { perror(" at point 2 in init_terminal() "); exit(errno); } /* stick a junk value into value pointer. this may be replaced by the constant read from a file (if called by read_tree()) or the constant value of the leaf being copied (if called by copy_tree()) or by a random value if called form create_random_tree */ *(t->type.term->valptr) = junk; } else { t->type.term->valptr = &(terminal_val(t)); } } #ifdef ANSI_FUNC tree *copy_tree( tree *t ) #else tree *copy_tree(t) tree *t; #endif { switch (t->nodetype) { case FUNCTION: return copy_function(t); case TERMINAL: return copy_terminal(t); default: fprintf(stderr, "nodetype %d must be %d or %d in copy_tree() \n", t->nodetype, FUNCTION, TERMINAL); return (tree *) NULL; } } #ifdef ANSI_FUNC tree *copy_function( tree *t ) #else tree *copy_function(t) tree *t; #endif { tree *nt; int i; pop_struct *pop = POP; nt = create_tree_node(t->pop,t->nodetype, t->id); for (i=0; i < function_arity(t); i++ ) { nt->type.func->arg[i] = copy_tree(t->type.func->arg[i]); } return nt; } #ifdef ANSI_FUNC tree *copy_terminal( tree *t ) #else tree *copy_terminal(t) tree *t; #endif { tree *nt; pop_struct *pop = POP; nt = create_tree_node(t->pop,t->nodetype, t->id); if (terminal_is_constant(t)) { *(nt->type.term->valptr) = (*(t->type.term->valptr)); } return nt; } #ifdef ANSI_FUNC VOID free_tree( tree *t ) #else VOID free_tree(t) tree *t; #endif { switch (t->nodetype) { case FUNCTION: free_function(t); break; case TERMINAL: free_terminal(t); break; default: fprintf(stderr, "nodetype %d must be %d or %d in free_tree() \n", t->nodetype, FUNCTION, TERMINAL); } } #ifdef ANSI_FUNC VOID free_function( tree *t ) #else VOID free_function(t) tree *t; #endif { int i; pop_struct *pop = POP; for (i=0; i < function_arity(t); i++ ) { free_tree(t->type.func->arg[i]); } free(t->type.func->arg); free(t->type.func->argvals); free(t->type.func); free(t); } #ifdef ANSI_FUNC VOID free_terminal( tree *t ) #else VOID free_terminal(t) tree *t; #endif { pop_struct *pop = POP; if (terminal_is_constant(t)) { free(t->type.term->valptr); } free(t->type.term); free(t); }