/// <summary>
/// Initializes a new instance of the Expression class.
/// </summary>
/// <param name="slot">The slot that this expression resides in.</param>
/// <param name="type">The type of this expression.</param>
/// <param name="domain">The domain of the expression. If this value is <c>null</c>, the
/// domain is considered to be all real numbers (i.e. no domain).</param>
protected Expression(int slot, ExpressionType type, CompiledDomain domain = null)
{
Slot = slot;
Type = type;
Color = Color.Black;
Domain = domain ?? DomainCompiler.EmptyDomain;
}
static DomainCompiler()
{
DynamicMethod method = GetDomainDynamicMethod();
ILGenerator il = method.GetILGenerator();
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Ret);
EmptyDomain = new CompiledDomain(method, null, new List<Constraint>());
}
/// <summary>
/// Initializes a new instance of the StandardExpression class.
/// </summary>
/// <param name="slot">The slot this expression resides in. Used as an identifier when
/// graphing.</param>
/// <param name="type">The type of expression this instance represents. Do not use
/// <see cref="ExpressionType.Parametric"/>; use the <see cref="ParametricExpression"/>
/// class instead.</param>
/// <param name="expr">The expression this instance represents.</param>
/// <remarks>
/// This constructor assumes that <paramref name="expr"/> is formatted as an infix
/// expression, and will be automatically compiled using the infix compiler.
/// </remarks>
public StandardExpression(int slot, ExpressionType type, string expr, CompiledDomain domain = null)
: base(slot, type, domain)
{
if (type == ExpressionType.Parametric)
{
throw new ArgumentException(
"ExpressionType.Parametric is not valid for this class. " +
"Use the ParametricExpression class instead.",
"type");
}
Expression = ExpressionCompiler.CompileInfix(expr);
}
/// <summary>
/// Initializes a new instance of the ParametricExpression class.
/// </summary>
/// <param name="slot">The slot this expression resides in. Used as an identifier when
/// graphing.</param>
/// <param name="x">The infix expression used in the "x = " portion of a parametric
/// expression.</param>
/// <param name="y">The infix expression used in the "y = " portion of a parametric
/// expression.</param>
/// <remarks>
/// This constructor assumes that the <paramref name="x"/> and <paramref name="y"/>
/// are formatted as infix expressions, and will be automatically compiled using the
/// infix compiler.
/// </remarks>
public ParametricExpression(int slot, string x, string y, CompiledDomain domain = null)
: base(slot, ExpressionType.Parametric, domain)
{
XExpression = ExpressionCompiler.CompileInfix(x);
YExpression = ExpressionCompiler.CompileInfix(y);
}
public ExpressionInfo(UncompiledExpression expr, CompiledDomain domain = null)
{
if (expr is UncompiledStandardExpression)
{
var stdExpr = expr as UncompiledStandardExpression;
Expression = new StandardExpression(expr.Slot, expr.Type, stdExpr.Expression, domain);
}
else if (expr is UncompiledParametricExpression)
{
var paraExpr = expr as UncompiledParametricExpression;
Expression = new ParametricExpression(expr.Slot, paraExpr.XExpression, paraExpr.YExpression, domain);
}
else
{
throw new ArgumentException("expr");
}
OriginalUncompiled = expr;
Enabled = true;
}
