Changeset 751 for cpp/frams

Timestamp:

02/28/18 23:41:58 (7 years ago)

Author:

Maciej Komosinski

Message:

More versatile mutation function for numbers

Location:

cpp/frams/genetics

Files:

• oper_fx.cpp (modified) (4 diffs)
• oper_fx.h (modified) (1 diff)

cpp/frams/genetics/oper_fx.cpp

@@ -80 +80 @@
 double GenoOperators::mutateNeuProperty(double current, Neuro *n, int i)
 {
-        if (i == -1) return mutateCreepNoLimit('f', current, -10, 10); //i==-1: mutating weight of neural connection
+        if (i == -1) return mutateCreepNoLimit('f', current, 2, true); //i==-1: mutating weight of neural connection
         Param p;
         if (i >= 100) { i -= 100; p = n->getClass()->getProperties(); }
@@ -97 +97 @@
         ExtValue ev;
         p.get(i, ev);
-        ev.setDouble(mutateCreep(p.type(i)[0], ev.getDouble(), mn, mx));
+        ev.setDouble(mutateCreep(p.type(i)[0], ev.getDouble(), mn, mx, true));
         p.set(i, ev);
         return true;
@@ -123 +123 @@
                 double mn, mx, df;
                 getMinMaxDef(&p, i, mn, mx, df);
-                newval = mutateCreep(p.type(i)[0], oldval, mn, mx);
+                newval = mutateCreep(p.type(i)[0], oldval, mn, mx, true);
                         }
         return true;
 }
 
-double GenoOperators::mutateCreepNoLimit(char type, double current, double mn, double mx)
-{
-        double result = RndGen.Gauss(current, (mx - mn) / 2 / 5); // /halfinterval, 5 times narrower
-        if (type == 'd') { result = int(result + 0.5); if (result == current) result += randomN(2) * 2 - 1; }
-        else result = floor(result * 1000 + 0.5) / 1000.0; //round
+double GenoOperators::mutateCreepNoLimit(char type, double current, double stddev, bool limit_precision_3digits)
+{
+        double result = RndGen.Gauss(current, stddev);
+        if (type == 'd')
+        {
+                result = int(result + 0.5);
+                if (result == current) result += randomN(2) * 2 - 1; //force some change
+        }
+        else
+        {
+                if (limit_precision_3digits)
+                        result = floor(result * 1000 + 0.5) / 1000.0; //round
+        }
         return result;
 }
 
-double GenoOperators::mutateCreep(char type, double current, double mn, double mx)
-{
-        double result = mutateCreepNoLimit(type, current, mn, mx); //TODO consider that when boundary is touched (reflect/absorb below), the default precision (3 digits) may change. Is it good or bad?
+double GenoOperators::mutateCreep(char type, double current, double mn, double mx, double stddev, bool limit_precision_3digits)
+{
+        double result = mutateCreepNoLimit(type, current, stddev, limit_precision_3digits);
+        //TODO consider that when boundary is touched (reflect+absorb below), the requested precision (3 digits) may change. Is it good or bad?
         //reflect:
         if (result > mx) result = mx - (result - mx); else
@@ -146 +155 @@
                 if (result < mn) result = mn;
         return result;
+}
+
+double GenoOperators::mutateCreep(char type, double current, double mn, double mx, bool limit_precision_3digits)
+{
+        double stddev = (mx - mn) / 2 / 5; // magic arbitrary formula for stddev, which becomes /halfinterval, 5 times narrower
+        return mutateCreep(type, current, mn, mx, stddev, limit_precision_3digits);
 }
 

cpp/frams/genetics/oper_fx.h

@@ -187 +187 @@
         static bool mutateProperty(ParamInterface &p, int propindex); ///<like mutatePropertyNaive(), but uses special probability distributions for some neuron properties.
         static bool getMutatedProperty(ParamInterface &p, int i, double oldval, double &newval); ///<like mutateProperty(), but just returns \e newval, does not get nor set it using \e p.
-        static double mutateCreepNoLimit(char type, double current, double mn, double mx); ///<returns \e current value creep-mutated with Gaussian distribution within [ \e mn , \e mx ] interval. Forced precision: 3 digits after comma. \e type must be either 'd' (integer) or 'f' (float/double).
-        static double mutateCreep(char type, double current, double mn, double mx); ///<just as mutateCreepNoLimit(), but forces mutated value into the [mn,mx] range using the 'reflect' approach.
+        static double mutateCreepNoLimit(char type, double current, double stddev, bool limit_precision_3digits); ///<returns \e current value creep-mutated with Gaussian distribution and \e stddev standard deviation. Precision limited to 3 digits after comma when \e limit_precision_3digits is true. \e type must be either 'd' (integer) or 'f' (float/double).
+        static double mutateCreep(char type, double current, double mn, double mx, double stddev, bool limit_precision_3digits); ///<just as mutateCreepNoLimit(), but forces mutated value into the [mn,mx] range using the 'reflect' approach.
+        static double mutateCreep(char type, double current, double mn, double mx, bool limit_precision_3digits); ///<just as mutateCreepNoLimit(), but forces mutated value into the [\e mn,\e mx] range using the 'reflect' approach and assumes standard deviation to be a fraction of the mx-mn interval width.
         static void setIntFromDoubleWithProbabilisticDithering(ParamInterface &p, int index, double value); ///<sets a double value in an integer field; when a value is non-integer, applies random "dithering" so that both lower and higher integer value have some chance to be set.
         static void linearMix(vector<double> &p1, vector<double> &p2, double proportion); ///<mixes two real-valued vectors; inherited proportion should be within [0,1]; 1.0 does not change values (all inherited), 0.5 causes both vectors to become their average, 0.0 swaps values (none inherited).