Changeset 196 for cpp/frams/genetics/f4/f4_general.h

Timestamp:

03/25/14 03:22:37 (10 years ago)

Author:

Maciej Komosinski

Message:

Updated f4 sources and made f4 available for GDK demo apps

Location:

cpp/frams/genetics/f4

Files:

• . (added)
• f4_general.h (moved) (moved from cpp/_old/f4/f4_general.h) (6 diffs)

cpp/frams/genetics/f4/f4_general.h

@@ -1 @@
-/*
- *  f4_general.h - f4 genotype functions.
- *
- *  f4genotype - f4 format genotype conversions for FramSticks
- *
- *  Copyright (C) 1999,2000  Adam Rotaru-Varga (adam_rotaru@yahoo.com)
- *
- *  This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Lesser General Public
- *  License as published by the Free Software Foundation; either
- *  version 2.1 of the License, or (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public
- *  License along with this library; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
+// This file is a part of the Framsticks GDK.
+// Copyright (C) 2002-2014  Maciej Komosinski and Szymon Ulatowski.  See LICENSE.txt for details.
+// Refer to http://www.framsticks.com/ for further information.
+
+// Copyright (C) 1999,2000  Adam Rotaru-Varga (adam_rotaru@yahoo.com), GNU LGPL
 
 #ifndef _F4_GENERAL_H_
 #define _F4_GENERAL_H_
 
-#include "f4_orientmat.h"
-#include "3d.h"
-#include "sstring.h"
-#include "multirange.h"
+//#include "f4_orientmat.h"
+#include <frams/util/3d.h>
+#include <frams/util/sstring.h>
+#include <frams/util/multirange.h>
 
 #ifdef DMALLOC
@@ -37 +20 @@
 class f4_Props
 {
- public:
-  // fill with default values
-  f4_Props();
-  // must sum to 1
-  void normalizeBiol4();
-  void executeModifier(char modif);
-  void adjust();
-
-  double len;      // length (dlug)
-  double curv;     // curvedness (skr)
-  double mass;
-  double friction;
-  double ruch;
-  double assim;
-  double odpor;
-  double ingest;  // ingestion (wchl)
-  double twist;
-  double energ;
+public:
+        // fill with default values
+        f4_Props();
+        // must sum to 1
+        void normalizeBiol4();
+        void executeModifier(char modif);
+        void adjust();
+
+        double len;      // length (dlug)
+        double curv;     // curvedness (skr)
+        double mass;
+        double friction;
+        double ruch;
+        double assim;
+        double odpor;
+        double ingest;  // ingestion (wchl)
+        double twist;
+        double energ;
 };
 
@@ -85 +68 @@
 {
 public:
-  class repeat_ptr
-  {
-   public:
-    repeat_ptr() : node(NULL), count(-1) { };
-    repeat_ptr(f4_node * a, int b) : node(a), count(b) { };
-    inline void null() { node = NULL; count = -1; };
-    inline bool isNull() const { return ((node == NULL) || (count <= 0)); };
-    inline void dec() { count--; };
-    f4_node *  node;  // ptr to repetition code
-    char       count; // repetition counter
-  };
-
-  class repeat_stack  // a stack of repet_ptr's
-  {
-   public:
-    repeat_stack() { top=0; };
-    inline void null() { top=0; };
-    inline void push(repeat_ptr A) { if (top>=stackSize) return; ptr[top]=A; top++; };
-    inline void pop() { if (top>0) top--; };
-    inline repeat_ptr * first() { return &(ptr[top-(top>0)]); };
-    static const int stackSize = 4;  // max 4 nested levels
-    repeat_ptr ptr[stackSize];
-    short int top;  // top of the stack
-  };
-
-  f4_Cell(int nname,
-    f4_Cell * ndad, int nangle, f4_Props newP);
-  f4_Cell(f4_Cells * nO, int nname, f4_node * ngeno, f4_node * ngcur,
-    f4_Cell * ndad, int nangle, f4_Props newP);
-  ~f4_Cell();
-
-  int onestep();        // execute one simulation step (till a division)
-
-  int   addlink(f4_Cell * nfrom, double nw, long nt);
-  void  adjustRec();
-
-  int        name;     // name (number)
-  int        type;     // type
-  f4_Cell *  dadlink;
-  f4_Cells * org;       // uplink to organism
-
-  f4_node *  genot;       // genotype
-  f4_node *  gcur;        // current genotype execution pointer
-  int        active;      // whether development is still active
-  repeat_stack repeat;
-  int        recProcessedFlag;  // used during recursive traverse
-  // remember the genotype codes affecting this cell so far
-  MultiRange genoRange;
-
-  f4_Props     P;             // properties
-  int          anglepos;      // number of position within dad's children (,)
-  int          childcount;    // number of children
-  int          commacount;    // number of postitions at lastend (>=childcount)
-  double       rolling;       // rolling angle ('R') (around x)
-  double       xrot;
-  double       zrot;          // horizontal rotation angle due to
-                              // branching (around z)
-  //Pt3D         firstend;      // coord.s of first end (connects to parent)
-  //Pt3D         lastend;       // last end
-  //f4_OrientMat OM;
-  double       mz;            // freedom in z
-  long         p2_refno;   // number of last end part object, used in f0
-  long         joint_refno;   // number of the joint object, used in f0
-  long         neuro_refno;   // number of the neuro object, used in f0
-
-  long         ctrl;  // neuron type
-  double       state;
-  double       inertia;
-  double       force;
-  double       sigmo;
-  f4_CellLink* links[MAXINPUTS];
-  int          nolink;
+        class repeat_ptr
+        {
+        public:
+                repeat_ptr() : node(NULL), count(-1) { };
+                repeat_ptr(f4_node * a, int b) : node(a), count(b) { };
+                inline void null() { node = NULL; count = -1; };
+                inline bool isNull() const { return ((node == NULL) || (count <= 0)); };
+                inline void dec() { count--; };
+                f4_node *  node;  // ptr to repetition code
+                char       count; // repetition counter
+        };
+
+        class repeat_stack  // a stack of repet_ptr's
+        {
+        public:
+                repeat_stack() { top = 0; };
+                inline void null() { top = 0; };
+                inline void push(repeat_ptr A) { if (top >= stackSize) return; ptr[top] = A; top++; };
+                inline void pop() { if (top > 0) top--; };
+                inline repeat_ptr * first() { return &(ptr[top - (top > 0)]); };
+                static const int stackSize = 4;  // max 4 nested levels
+                repeat_ptr ptr[stackSize];
+                short int top;  // top of the stack
+        };
+
+        f4_Cell(int nname,
+                f4_Cell * ndad, int nangle, f4_Props newP);
+        f4_Cell(f4_Cells * nO, int nname, f4_node * ngeno, f4_node * ngcur,
+                f4_Cell * ndad, int nangle, f4_Props newP);
+        ~f4_Cell();
+
+        int onestep();  // execute one simulation step (till a division)
+
+        int   addlink(f4_Cell * nfrom, double nw, long nt);
+        void  adjustRec();
+
+        int        name;     // name (number)
+        int        type;     // type
+        f4_Cell *  dadlink;
+        f4_Cells * org; // uplink to organism
+
+        f4_node *  genot;         // genotype
+        f4_node *  gcur;        // current genotype execution pointer
+        int        active;      // whether development is still active
+        repeat_stack repeat;
+        int        recProcessedFlag;  // used during recursive traverse
+        // remember the genotype codes affecting this cell so far
+        MultiRange genoRange;
+
+        f4_Props     P;             // properties
+        int          anglepos;      // number of position within dad's children (,)
+        int          childcount;    // number of children
+        int          commacount;    // number of postitions at lastend (>=childcount)
+        double       rolling;       // rolling angle ('R') (around x)
+        double       xrot;
+        double       zrot;          // horizontal rotation angle due to
+        // branching (around z)
+        //Pt3D         firstend;      // coord.s of first end (connects to parent)
+        //Pt3D         lastend;       // last end
+        //f4_OrientMat OM;
+        double       mz;            // freedom in z
+        long         p2_refno;   // number of last end part object, used in f0
+        long         joint_refno;   // number of the joint object, used in f0
+        long         neuro_refno;   // number of the neuro object, used in f0
+
+        long         ctrl;  // neuron type
+        double       state;
+        double       inertia;
+        double       force;
+        double       sigmo;
+        f4_CellLink* links[MAXINPUTS];
+        int          nolink;
 };
 
@@ -164 +147 @@
 {
 public:
-               f4_CellLink(f4_Cell * nfrom, double nw, long nt);
-  f4_Cell *    from;
-  // type: 0: input, 1 '*', 2 'G', 3 'T', 4 'S'
-  long         t;
-  double       w;
+        f4_CellLink(f4_Cell * nfrom, double nw, long nt);
+        f4_Cell *    from;
+        // type: 0: input, 1 '*', 2 'G', 3 'T', 4 'S'
+        long         t;
+        double       w;
 };
 
@@ -176 +159 @@
 class f4_Cells
 {
- public:
-  f4_Cells(f4_node * genome, int nrepair);
-  f4_Cells(SString &genome, int nrepair);
-  ~f4_Cells();
-  void addCell(f4_Cell * newcell);
-  void toF1Geno(SString &out);       // output to f1 format, approximation
-  int  onestep();       // simulate all parts for one step
-  int  simulate();      // simulate development, return error (0 for ok)
-  // for error reporting / genotype fixing
-  int  geterror() { return error;};
-  int  geterrorpos() { return errorpos;};
-  void setError(int nerrpos);
-  void setRepairRemove(int nerrpos, f4_node * rem);
-  int  setRepairInsert(int nerrpos, f4_node * parent, f4_node * insert);
-  void repairGeno(f4_node * geno, int whichchild);
-
-  // the cells
-  f4_Cell * C[MAX4CELLS];
-  int       nc;
+public:
+        f4_Cells(f4_node * genome, int nrepair);
+        f4_Cells(SString &genome, int nrepair);
+        ~f4_Cells();
+        void addCell(f4_Cell * newcell);
+        void toF1Geno(SString &out);       // output to f1 format, approximation
+        int  onestep();       // simulate all parts for one step
+        int  simulate();      // simulate development, return error (0 for ok)
+        // for error reporting / genotype fixing
+        int  geterror() { return error; };
+        int  geterrorpos() { return errorpos; };
+        void setError(int nerrpos);
+        void setRepairRemove(int nerrpos, f4_node * rem);
+        int  setRepairInsert(int nerrpos, f4_node * parent, f4_node * insert);
+        void repairGeno(f4_node * geno, int whichchild);
+
+        // the cells
+        f4_Cell * C[MAX4CELLS];
+        int       nc;
 
 private:
-  // for error reporting / genotype fixing
-  int repair;
-  int error;
-  int errorpos;
-  f4_node * repair_remove;
-  f4_node * repair_parent;
-  f4_node * repair_insert;
-  void toF1GenoRec(int curc, SString &out);
-  f4_Cell * tmpcel;             // needed by toF1Geno
-  f4_node * f4rootnode;          // used by constructor
+        // for error reporting / genotype fixing
+        int repair;
+        int error;
+        int errorpos;
+        f4_node * repair_remove;
+        f4_node * repair_parent;
+        f4_node * repair_insert;
+        void toF1GenoRec(int curc, SString &out);
+        f4_Cell * tmpcel;               // needed by toF1Geno
+        f4_node * f4rootnode;          // used by constructor
 };
 
@@ -216 +199 @@
 {
 public:
-  char      name;       // one-letter 'name'
-  f4_node * parent;     // parent link, or NULL
-  f4_node * child;      // child, or NULL
-  f4_node * child2;     // second child, or NULL
-  int       pos;        // original position in string
-  int       i1;         // internal int  parameter1
-  long      l1;         // internal long parameter1
-  double    f1;         // internal double parameter1
-
-            f4_node();
-            f4_node(char nname, f4_node * nparent, int npos);
-            ~f4_node();
-  int       addChild(f4_node * nchi);
-  int       removeChild(f4_node * nchi);
-  int       childCount();       // return no of children, 0, 1, or 2
-  int       count();    // return no of nodes (recursive)
-  f4_node * ordNode(int n);     // returns the nth subnode (0-)
-  f4_node * randomNode();       // returns a random subnode
-  f4_node * randomNodeWithSize(int min, int max);       // returns a random subnode with given size
-  void      sprintAdj(char *& buf);     // print recursively
-  f4_node * duplicate();         // create duplicate copy. recursive.
-  void      destroy();  // release memory. recursive.
+        char      name; // one-letter 'name'
+        f4_node * parent;       // parent link, or NULL
+        f4_node * child;        // child, or NULL
+        f4_node * child2;       // second child, or NULL
+        int       pos;        // original position in string
+        int       i1;           // internal int  parameter1
+        long      l1;           // internal long parameter1
+        double    f1;           // internal double parameter1
+
+        f4_node();
+        f4_node(char nname, f4_node * nparent, int npos);
+        ~f4_node();
+        int       addChild(f4_node * nchi);
+        int       removeChild(f4_node * nchi);
+        int       childCount(); // return no of children, 0, 1, or 2
+        int       count();      // return no of nodes (recursive)
+        f4_node * ordNode(int n);       // returns the nth subnode (0-)
+        f4_node * randomNode(); // returns a random subnode
+        f4_node * randomNodeWithSize(int min, int max); // returns a random subnode with given size
+        void      sprintAdj(char *& buf);       // print recursively
+        f4_node * duplicate();         // create duplicate copy. recursive.
+        void      destroy();    // release memory. recursive.
 private:
-  void     sprint(SString & out);       // print recursively
+        void     sprint(SString & out); // print recursively
 };