/// <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 GeneticBool EvaluateOperator(OperatorSignature signature, GeneticObject lhs, GeneticObject rhs)
{
GeneticObject.ValidateOperatorCall(signature, typeof(GeneticBool), lhs, rhs);
switch (signature.Value)
{
case "<":
return(GeneticBool.OperatorLessThan((GeneticInt)lhs, (GeneticInt)rhs));
case ">":
return(GeneticBool.OperatorGreaterThan((GeneticInt)lhs, (GeneticInt)rhs));
case "==":
return(GeneticBool.OperatorEquals(lhs, rhs));
case "!=":
return(GeneticBool.OperatorNotEquals(lhs, rhs));
case "&&":
return(GeneticBool.OperatorAnd((GeneticBool)lhs, (GeneticBool)rhs));
case "||":
return(GeneticBool.OperatorAnd((GeneticBool)lhs, (GeneticBool)rhs));
}
throw new InvalidOperationException(string.Format(
"Did not recognize operator with signature {0} with return type {1}",
signature.Value,
signature.ReturnType));
}
private static GeneticBool OperatorNotEquals(GeneticObject lhs, GeneticObject rhs)
{
if (lhs is GeneticInt && rhs is GeneticInt)
{
return(GeneticBool.OperatorNotEquals((GeneticInt)lhs, (GeneticInt)rhs));
}
if (lhs is GeneticBool && rhs is GeneticBool)
{
return(GeneticBool.OperatorNotEquals((GeneticBool)lhs, (GeneticBool)rhs));
}
throw new InvalidOperationException("Could not cast arguemnts as expected");
}
/// <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));
}
public static void RegisterOperatorsForAllTypes()
{
GeneticBool.RegisterOperators();
GeneticInt.RegisterOperators();
}
private static GeneticBool OperatorOr(GeneticBool lhs, GeneticBool rhs)
{
return(new GeneticBool(lhs.Value || rhs.Value));
}
private static GeneticBool OperatorAnd(GeneticBool lhs, GeneticBool rhs)
{
return(new GeneticBool(lhs.Value && rhs.Value));
}
private static GeneticBool OperatorNotEquals(GeneticBool lhs, GeneticBool rhs)
{
return(new GeneticBool(lhs.Value != rhs.Value));
}
