public override void Accept(TSqlFragmentVisitor visitor)
{
visitor.ExplicitVisit(this);
FirstExpression?.Accept(visitor);
SecondExpression?.Accept(visitor);
}
public override object Evaluate()
{
Func <Complex, Complex> targetFunc = FirstExpression.EvaluateAsFunction <Complex>(ThirdExpression);
Complex x = SecondExpression.EvaluateAsComplex();
return(NumericalDerivation.SecondDerivative(targetFunc, x));
}
public void Demangle(DemanglingContext context)
{
SimpleOperatorName question = OperatorName as SimpleOperatorName;
if (question.Value == SimpleOperatorName.Values.Question)
{
FirstExpression.Demangle(context);
context.Writer.Append(" ? ");
SecondExpression.Demangle(context);
context.Writer.Append(" : ");
ThirdExpression.Demangle(context);
}
else
{
// Nonsensical ternary operator? Just print it like a function call,
// I suppose...
//
// TODO: should we detect and reject this during parsing?
OperatorName.Demangle(context);
context.Writer.Append("(");
FirstExpression.Demangle(context);
context.Writer.Append(", ");
SecondExpression.Demangle(context);
context.Writer.Append(", ");
ThirdExpression.Demangle(context);
context.Writer.Append(")");
}
}
public override object Evaluate()
{
double x = FirstExpression.EvaluateAsReal();
double y = SecondExpression.EvaluateAsReal();
double z = ThirdExpression.EvaluateAsReal();
return(new CMatrix(CoordSysConverter.CartesianToSpherical(x, y, z)));
}
public override object Evaluate()
{
double mean = FirstExpression.EvaluateAsReal();
double stdev = SecondExpression.EvaluateAsReal();
double x = ThirdExpression.EvaluateAsReal();
return((Complex) new NormalDistribution(mean, stdev).CumulativeDistributionFunction(x));
}
public override object Evaluate()
{
double a = FirstExpression.EvaluateAsReal();
double b = SecondExpression.EvaluateAsReal();
double x = ThirdExpression.EvaluateAsReal();
return((Complex) new UniformDistribution(a, b).CumulativeDistributionFunction(x));
}
public override object Evaluate()
{
double r = FirstExpression.EvaluateAsReal();
double theta = SecondExpression.EvaluateAsReal();
double phi = ThirdExpression.EvaluateAsReal();
return(new CMatrix(CoordSysConverter.SphericalToCartesian(r, theta, phi)));
}
public override object Evaluate()
{
IList <double> xValues = FirstExpression.EvaluateAsRealVector();
IList <double> yValues = SecondExpression.EvaluateAsRealVector();
double x = ThirdExpression.EvaluateAsReal();
return((Complex)(new NewtonPolynomialInterpolator(xValues, yValues).Interpolate(x)));
}
public override object Evaluate()
{
Func <Complex, Complex> targetFunc = FirstExpression.EvaluateAsFunction <Complex>(ThirdExpression);
Complex initGuess = SecondExpression.EvaluateAsComplex();
ComplexMullerEquationSolver solver = new ComplexMullerEquationSolver(targetFunc, initGuess);
return(solver.Solve());
}
public override void ForEachBlock(
CodegenBlock block,
CodegenMethod methodNode,
ExprForgeCodegenSymbol scope,
CodegenClassScope codegenClassScope)
{
block.DeclareVar <object>("key", InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.DeclareVar <object>("value", SecondExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.Expression(ExprDotMethod(Ref("map"), "Put", Ref("key"), Ref("value")));
}
public override object Evaluate()
{
if (ThirdExpression == Expression <Object> .Null)
{
return(FirstExpression.EvaluateAsCMatrix()[SecondExpression.EvaluateAsInt32()]);
}
else
{
return(FirstExpression.EvaluateAsCMatrix()[SecondExpression.EvaluateAsInt32(), ThirdExpression.EvaluateAsInt32()]);
}
}
public override object Evaluate()
{
double a = FirstExpression.EvaluateAsReal();
double b = SecondExpression.EvaluateAsReal();
int count = ThirdExpression.EvaluateAsInt32();
PerformanceManager.Current.EnsureAcceptableArraySize(count);
double[] v = new double[count];
new UniformDistribution(a, b).GetRandomVariables(_random, v);
return(new CMatrix(v));
}
public override void ForEachBlock(
CodegenBlock block,
CodegenMethod methodNode,
ExprForgeCodegenSymbol scope,
CodegenClassScope codegenClassScope)
{
block.DeclareVar <object>("key", InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.DeclareVar <object>("entry", SecondExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.DeclareVar <ICollection <object> >("value", Cast(typeof(ICollection <object>), ExprDotMethod(Ref("result"), "Get", Ref("key"))))
.IfRefNull("value")
.AssignRef("value", NewInstance(typeof(List <object>)))
.Expression(ExprDotMethod(Ref("result"), "Put", Ref("key"), Ref("value")))
.BlockEnd()
.Expression(ExprDotMethod(Ref("value"), "Add", Ref("entry")));
}
public override void ToString(StringBuilder buf, int indent)
{
FirstExpression.ToString(buf, indent);
if (NotDefined)
{
buf.Append(" NOT LIKE ");
}
else
{
buf.Append(" LIKE ");
}
SecondExpression.ToString(buf, indent);
}
public override void ToString(StringBuilder buf, int indent)
{
FirstExpression.ToString(buf, indent);
switch (TernaryExpressionType)
{
case BooleanTernaryExpressionType.Between:
buf.Append(" BETWEEN ");
break;
case BooleanTernaryExpressionType.NotBetween:
buf.Append(" NOT BETWEEN ");
break;
default:
throw new NotImplementedException();
}
SecondExpression.ToString(buf, indent);
buf.Append(" AND ");
ThirdExpression.ToString(buf, indent);
}
public override void ToString(StringBuilder buf, int indent)
{
FirstExpression.ToString(buf, indent);
buf.Append("\r\n");
buf.Append(' ', indent);
switch (BinaryExpressionType)
{
case BooleanBinaryExpressionType.And:
buf.Append("AND ");
break;
case BooleanBinaryExpressionType.Or:
buf.Append("OR ");
break;
default:
throw new NotImplementedException();
}
SecondExpression.ToString(buf, indent);
}
public override void ToString(StringBuilder buf, int indent)
{
FirstExpression.ToString(buf, indent);
switch (ComparisonType)
{
case BooleanComparisonType.Equals:
buf.Append(" = ");
break;
case BooleanComparisonType.GreaterThan:
buf.Append(" > ");
break;
case BooleanComparisonType.GreaterThanOrEqualTo:
buf.Append(" >= ");
break;
case BooleanComparisonType.LessThan:
buf.Append(" < ");
break;
case BooleanComparisonType.LessThanOrEqualTo:
buf.Append(" <= ");
break;
case BooleanComparisonType.NotEqualToBrackets:
buf.Append(" <> ");
break;
default:
throw new NotImplementedException();
}
SecondExpression.ToString(buf, indent);
}
public override string ToDisplayString() => $"{FirstExpression.ToDisplayString()} {Operator.ToDisplayString()} {SecondExpression.ToDisplayString()}";
public override IEnumerable <BindingParserNode> EnumerateNodes()
{
return(base.EnumerateNodes().Concat(FirstExpression.EnumerateNodes()).Concat(SecondExpression.EnumerateNodes()));
}
public override object Evaluate()
{
return(CMatrix.Minor(FirstExpression.EvaluateAsCMatrix(), SecondExpression.EvaluateAsInt32(), ThirdExpression.EvaluateAsInt32()));
}
