Index: cpp/frams/genetics/oper_fx.cpp
===================================================================
--- cpp/frams/genetics/oper_fx.cpp	(revision 750)
+++ cpp/frams/genetics/oper_fx.cpp	(revision 751)
@@ -80,5 +80,5 @@
 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,5 +97,5 @@
 	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,20 +123,29 @@
 		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,4 +155,10 @@
 		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);
 }
 
Index: cpp/frams/genetics/oper_fx.h
===================================================================
--- cpp/frams/genetics/oper_fx.h	(revision 750)
+++ cpp/frams/genetics/oper_fx.h	(revision 751)
@@ -187,6 +187,7 @@
 	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).
