source: cpp/_old/f8-to-f1/conv_f8tof1.h @ 1189

Last change on this file since 1189 was 193, checked in by Maciej Komosinski, 10 years ago

Set svn:eol-style native for all textual files

  • Property svn:eol-style set to native
File size: 7.8 KB
Line 
1/*
2 *  conv_f8tof1.h
3 *  L-systemToF1
4 *
5 *  Created by Maciej Wajcht on 08-03-21.
6 *  Copyright 2008 __MyCompanyName__. All rights reserved.
7 *
8 */
9
10#ifndef _CONV_F8_TO_F1_H
11#define _CONV_F8_TO_F1_H
12
13#include <map>
14#include <vector>
15#include <string>
16#include <list>
17#include <iostream>
18#include "genoconv.h"
19#include "model.h"
20
21using std::ostream;
22using std::vector;
23using std::list;
24using std::string;
25using std::map;
26
27enum RelationType {
28        r_greater,
29        r_greaterEqual,
30        r_less,
31        r_lessEqual,
32        r_equal,
33        r_different
34};
35
36class Condition {
37public:
38        RelationType relation;
39        SString parameter;
40        double value;
41       
42        friend ostream& operator<<(ostream& os, const Condition& c);
43};
44
45class ActionP; //only declaration
46
47/// superclass of all actions, e.g. Production, PrimitiveProduction etc.
48class Action {
49public:
50        /// action's name
51        SString name;
52        /// if true action should ignore params passed to it
53        bool ignoreParams;
54        /// gets string representaion of this action in f1 format
55        virtual const SString getF1Genotype(vector<double> params) = 0;
56        /// gets list of actions with double parameters to each of them
57        /// @param params parameters passed to this action
58        virtual const list<ActionP> getActionList(const vector<double> params) = 0;
59        /// gets string representaion of this action in f8 format
60        virtual const SString getF8Representation() = 0;
61        virtual ~Action() {}
62};
63
64/// this class consists of pointer to some action and a list of parameters to that action;
65/// parameters are kept as strings
66class ActionStrP {
67public:
68        Action *action;
69        vector<SString> params;
70};
71
72/// this class consists of pointer to some action and a list of parameters to that action;
73/// parameters are kept as doubles
74class ActionP {
75public:
76        Action *action;
77        vector<double> params;
78};
79
80/// part of production which is used in translation only if all the conditions are met
81class SubProduction {
82public:
83        /// list of conditions necessary to be met
84        vector<Condition> conditions;
85        /// actions with params (as strings)
86        vector<ActionStrP> actions;
87};
88
89/// primitive production; it's directly translated to its f1 equivalent
90/// e.g. X, r, R etc.
91class PrimitiveProduction : public Action {
92public:
93        PrimitiveProduction(const SString command);
94        const SString getF1Genotype(const vector<double> params);
95        const list<ActionP> getActionList(const vector<double> params);
96        const SString getF8Representation();
97protected:
98        SString f1command;
99        SString f8command;
100};
101
102/// param production; all param productions during translation are replaced with the current value of parameter
103/// pointed by this production
104class ParamProduction : public Action {
105public:
106        ParamProduction(const SString paramName);
107        const SString getF1Genotype(const vector<double> params);
108        const list<ActionP> getActionList(const vector<double> params);
109        const SString getF8Representation();
110protected:
111        SString paramName;
112};
113
114/// neuron production; it is directly translated to f1 without any change
115class NeuronProduction : public Action {
116public:
117        NeuronProduction(SString body);
118        const SString getF1Genotype(const vector<double> params);
119        const list<ActionP> getActionList(const vector<double> params);
120        const SString getF8Representation();
121protected:
122        SString body;
123};
124
125/// class which keeps all parameters of a production and enables to access them in convenient way
126/// IMPORTANT! All indices (positions) begins with 1 (not 0)!
127class ParameterCollection {
128public:
129        /// returns parameter's value
130        /// @param position parameter's position (first parameter has an index 1!)
131        const double getValue(int position);
132        /// returns parameter's value
133        /// @param name parameter's name
134        const double getValue(SString name);
135        /// returns parameter's name
136        /// @param position parameter's position (first parameter has an index 1!)
137        const SString getParameterName(int position);
138        /// returns parameter's position (first parameter has an index 1!)
139        /// @param name parameter's name
140        const int getParameterPosition(SString name);
141        /// sets parameter's value
142        /// @param position parameter's position
143        /// @param value parameter's new value
144        void setValue(int position, double value);
145        /// sets parameter's value
146        /// @param name parameter's name
147        /// @param value parameter's new value
148        void setValue(SString name, double value);
149        /// adds parameter
150        /// @param name parameter's name
151        /// @param position desired parameter's position; defualts to -1 which means it will have first available position
152        /// @param value parameter's value; defaults to 0.0
153        void addParameter(SString name, int position = -1, double value = 0.0);
154        /// returns the number of parameters kept in this class
155        const int size();
156        /// removes a parameter
157        /// @param position position of parameter to be deleted
158        void removeParameter(int position);
159        /// removes a parameter
160        /// @param name name of parameter to be deleted
161        void removeParameter(SString name);
162        /// returns true if parameter with given name exists
163        /// @param name parameter's name
164        bool paramExist(SString name);
165protected:
166        vector<string> parameters;
167        map<string, double> paramValues;
168};
169
170/// represents a general rule in L-systems
171/// only "calls" to Production in genotype are replaced in translation procedure
172class Production : public Action {
173public:
174        /// parameters of this production
175        ParameterCollection parameters;
176        /// list of subproductions
177        vector<SubProduction> subproductions;
178       
179        Production();
180        ~Production() {};
181        const SString getF1Genotype(const vector<double> params);
182        const list<ActionP> getActionList(const vector<double> params);
183        const SString getF8Representation();
184};
185
186/// Main class that represents a genotype in f8 format
187class Lsystem {
188public:
189        /// number of iterations in f8->f1 translation procedure
190        int iterations;
191        /// map of parameters of start production; key - parameter's name, value - parameter's value
192        map<string, double> startParams;
193        /// map of productions of L-system; key - productions's name, value - pointer to production
194        map<string, Production*> productions;
195        /// collection of neuron productions held in L-system
196        vector<NeuronProduction*> neuronProductions;
197        /// first production's name
198        string firstProductionName;
199       
200        Lsystem();
201        ~Lsystem();
202        /// returns a primitive production of a given name
203        /// @param name primitive production's name
204        PrimitiveProduction* getPrimitiveProduction(SString name);
205        /// returns a param production of a given name
206        /// @param name param production's name
207        ParamProduction* getParamProduction(SString name);
208        /// gets string representation of this L-system (f8 genotype)
209        SString toString();
210        /// returns all actions
211        /// @param normal if true all normal actions will be included
212        /// @param primitives if true all primitive actions will be included
213        /// @param params if true all param actions will be included
214        /// @param neurons if true all neuron actions will be included
215        vector<Action*> getAllActions(bool normal, bool primitives, bool params, bool neurons);
216protected:
217        map<string, PrimitiveProduction*> primitiveProductions;
218        map<string, ParamProduction*> paramProductions;
219
220        void removeEmptySubproductionsAndProductions();
221};
222
223
224
225
226
227/// Converter between f8 and f1 format
228class GenoConv_F8ToF1 : public GenoConverter {
229public:
230        Param par;
231        static Param staticpar; //needed to add 'par' to the list of simulator params (this field is initialized externally)
232 
233        GenoConv_F8ToF1();
234        ~GenoConv_F8ToF1() {}
235
236        SString convert(SString &in, MultiMap *map);
237
238        /// check syntax of given f8 genotype
239        /// @param geno f8 genotype to be checked
240        bool checkSyntax(const char *geno);
241
242        /// returns names of productions in a given genotype
243        /// @param in f8 genotype
244        vector<SString> readProductionNames(const SString &in);
245        //Lsystem* createLsystem(const SString &in);
246
247        /// creates Lsystem object based on input genotype
248        /// @param f8 genotype
249        Lsystem* createLsystem(SString in);
250
251        int maxF1Length;
252        static const char* simpleprods;
253
254protected:
255        bool parseInput(const char* src, Lsystem* lsys);
256};
257
258#endif
Note: See TracBrowser for help on using the repository browser.