private static GeneticInt OperatorDivide(GeneticInt lhs, GeneticInt rhs)
{
if (rhs.Value == 0)
{
return(new GeneticInt(0));
}
return(new GeneticInt(lhs.Value / rhs.Value));
}
/// <summary>
/// Evaluates the operator.
/// </summary>
/// <returns>The operator.</returns>
/// <param name="signature">Signature.</param>
/// <param name="lhs">Lhs.</param>
/// <param name="rhs">Rhs.</param>
public static GeneticObject EvaluateOperator(OperatorSignature signature, GeneticObject lhs, GeneticObject rhs)
{
if (signature.ReturnType == typeof(GeneticInt))
{
return(GeneticInt.EvaluateOperator(signature, lhs, rhs));
}
if (signature.ReturnType == typeof(GeneticBool))
{
return(GeneticBool.EvaluateOperator(signature, lhs, rhs));
}
throw new InvalidOperationException(string.Format(
"{0} is missing implementation support for an operator {1}",
signature.ReturnType,
signature.Value));
}
/// <summary>
/// Creates the type at random.
/// </summary>
/// <returns>The type at random.</returns>
/// <param name="type">Type.</param>
public static GeneticObject CreateTypeAtRandom(Type type)
{
if (type == typeof(GeneticInt))
{
return(GeneticInt.CreateAtRandom());
}
if (type == typeof(GeneticBool))
{
return(GeneticBool.CreateAtRandom());
}
if (type == typeof(GeneticGridDirection))
{
return(GeneticGridDirection.CreateAtRandom());
}
throw new StatementParseException(string.Format("Type: {0} is missing implementation support as a Genetic type", type));
}
/// <summary>
/// Parses the value.
/// </summary>
/// <returns>The value.</returns>
/// <param name="type">Type.</param>
/// <param name="valueString">Value string.</param>
public static GeneticObject ParseValue(Type type, string valueString)
{
if (type == typeof(GeneticInt))
{
return(GeneticInt.FromString(valueString));
}
if (type == typeof(GeneticBool))
{
return(GeneticBool.FromString(valueString));
}
if (type == typeof(GeneticGridDirection))
{
return(GeneticGridDirection.FromString(valueString));
}
throw new StatementParseException(string.Format("Type: {0} is missing implementation support as a Genetic type", type));
}
/// <summary>
/// Evaluates the operator.
/// </summary>
/// <returns>The operator.</returns>
/// <param name="signature">Signature.</param>
/// <param name="lhs">Lhs.</param>
/// <param name="rhs">Rhs.</param>
new public static GeneticInt EvaluateOperator(OperatorSignature signature, GeneticObject lhs, GeneticObject rhs)
{
GeneticObject.ValidateOperatorCall(signature, typeof(GeneticInt), lhs, rhs);
switch (signature.Value)
{
case "+":
return(GeneticInt.OperatorPlus((GeneticInt)lhs, (GeneticInt)rhs));
case "-":
return(GeneticInt.OperatorMinus((GeneticInt)lhs, (GeneticInt)rhs));
case "*":
return(GeneticInt.OperatorMultiply((GeneticInt)lhs, (GeneticInt)rhs));
case "/":
return(GeneticInt.OperatorDivide((GeneticInt)lhs, (GeneticInt)rhs));
}
throw new InvalidOperationException(string.Format(
"Did not recognize operator with signature {0} with return type {1}",
signature.Value,
signature.ReturnType));
}
public static void RegisterOperatorsForAllTypes()
{
GeneticBool.RegisterOperators();
GeneticInt.RegisterOperators();
}
private static GeneticInt OperatorMultiply(GeneticInt lhs, GeneticInt rhs)
{
return(new GeneticInt(lhs.Value * rhs.Value));
}
private static GeneticInt OperatorMinus(GeneticInt lhs, GeneticInt rhs)
{
return(new GeneticInt(lhs.Value - rhs.Value));
}
private static GeneticBool OperatorNotEquals(GeneticInt lhs, GeneticInt rhs)
{
return(new GeneticBool(lhs.Value != rhs.Value));
}
private static GeneticBool OperatorGreaterThan(GeneticInt lhs, GeneticInt rhs)
{
return(new GeneticBool(lhs.Value > rhs.Value));
}
private static GeneticBool OperatorLessThan(GeneticInt lhs, GeneticInt rhs)
{
return(new GeneticBool(lhs.Value < rhs.Value));
}
