/// <summary>
/// Initializes a new instance of <see cref="DyadicFunction"/> AST node.
/// </summary>
/// <param name="token">The <see cref="Token"/> to use for the dyadic function.</param>
/// <param name="leftExpression">The left hand argument of the dyadic function.</param>
/// <param name="rightExpression">The right hand argument of the dyadic function.</param>
public DyadicFunction(Token token, Node leftExpression, Node rightExpression)
{
this.token = token;
this.leftExpression = leftExpression;
this.rightExpression = rightExpression;
MethodChooser.ConvertToDyadicToken(this.token);
}
/// <summary>
/// Builds a Node representing a <see cref="MonadicFunction"/> or a <see cref="DyadicFunction"/> based on the
/// number of arguments in the <paramref name="expressionList"/> parameter.
/// </summary>
/// <remarks>
/// Returned nodes based on the ExpressionList parameter (number of nodes inside the list):
/// - 1: MonadicFunction
/// - 2: DyadicFunction
/// - other cases: Create parse valence error
/// </remarks>
/// <param name="token">The <see cref="Token"/> representing the built-in function.</param>
/// <param name="expressionList">List of arguments for the built-in function.</param>
/// <exception cref="ParseException">Throws exception if the number of arguments is incorrect.</exception>
/// <returns></returns>
public static Node BuiltinInvoke(Token token, ExpressionList expressionList)
{
switch (expressionList.Length)
{
case 1:
return new MonadicFunction(token, expressionList[0]);
case 2:
return new DyadicFunction(token, expressionList[0], expressionList[1]);
default:
throw new ParseException("valence?", false);
}
}
/// <summary>
/// Return the A+ native monadic function for the specified monadic token
/// </summary>
/// <returns><b>null</b> if no monadic function found</returns>
internal static AbstractMonadicFunction GetMonadicMethod(Token token)
{
switch (token.Type)
{
#region Monadic Scalar
case Tokens.ABSOLUTEVALUE:
return MonadicFunctionInstance.AbosulteValue;
case Tokens.CEILING:
return MonadicFunctionInstance.Ceiling;
case Tokens.EXPONENTIAL:
return MonadicFunctionInstance.Exponential;
case Tokens.FLOOR:
return MonadicFunctionInstance.Floor;
case Tokens.IDENTITY:
return MonadicFunctionInstance.Identity;
case Tokens.NATURALLOG:
return MonadicFunctionInstance.NaturalLog;
case Tokens.NEGATE:
return MonadicFunctionInstance.Negate;
case Tokens.NOT:
return MonadicFunctionInstance.Not;
case Tokens.PITIMES:
return MonadicFunctionInstance.PiTimes;
case Tokens.RECIPROCAL:
return MonadicFunctionInstance.Reciprocal;
case Tokens.ROLL:
return MonadicFunctionInstance.Roll;
case Tokens.SIGN:
return MonadicFunctionInstance.Sign;
#endregion
#region Monadic Non Scalar
case Tokens.COUNT:
return MonadicFunctionInstance.Count;
case Tokens.DEPTH:
return MonadicFunctionInstance.Depth;
case Tokens.DISCLOSE:
return MonadicFunctionInstance.Disclose;
case Tokens.ENCLOSE:
return MonadicFunctionInstance.Enclose;
case Tokens.EXECUTE:
return MonadicFunctionInstance.ExecuteFunction;
case Tokens.DEFAULTFORMAT:
return MonadicFunctionInstance.DefaultFormat;
case Tokens.GRADEDOWN:
return MonadicFunctionInstance.GradeDown;
case Tokens.GRADEUP:
return MonadicFunctionInstance.GradeUp;
case Tokens.INTERVAL:
return MonadicFunctionInstance.Interval;
case Tokens.ITEMRAVEL:
return MonadicFunctionInstance.ItemRavel;
case Tokens.MAPIN:
return MonadicFunctionInstance.MapIn;
case Tokens.MATRIXINVERSE:
return MonadicFunctionInstance.MatrixInverse;
case Tokens.NULL:
return MonadicFunctionInstance.NullFunction;
case Tokens.PACK:
return MonadicFunctionInstance.Pack;
case Tokens.PARTITIONCOUNT:
return MonadicFunctionInstance.PartitionCount;
case Tokens.PRINT:
return MonadicFunctionInstance.Print;
case Tokens.RAKE:
return MonadicFunctionInstance.Rake;
case Tokens.RAVEL:
return MonadicFunctionInstance.Ravel;
case Tokens.RAZE:
return MonadicFunctionInstance.Raze;
case Tokens.REVERSE:
return MonadicFunctionInstance.Reverse;
case Tokens.RIGHT:
return MonadicFunctionInstance.Right;
case Tokens.SEPARATESYMBOLS:
return MonadicFunctionInstance.SeparateSymbols;
case Tokens.SHAPE:
return MonadicFunctionInstance.Shape;
case Tokens.SIGNAL:
return MonadicFunctionInstance.Signal;
case Tokens.STOP:
return MonadicFunctionInstance.Stop;
case Tokens.TRANSPOSE:
return MonadicFunctionInstance.Transpose;
case Tokens.TYPE:
return MonadicFunctionInstance.Type;
case Tokens.UNPACK:
return MonadicFunctionInstance.Unpack;
case Tokens.VALUE:
return MonadicFunctionInstance.Value;
#endregion
#region Monadic Operator
case Tokens.RADD:
return MonadicFunctionInstance.ReduceAdd;
case Tokens.RMULTIPLY:
return MonadicFunctionInstance.ReduceMultiply;
case Tokens.ROR:
return MonadicFunctionInstance.ReduceOr;
case Tokens.RAND:
return MonadicFunctionInstance.ReduceAnd;
case Tokens.RMAX:
return MonadicFunctionInstance.ReduceMax;
case Tokens.RMIN:
return MonadicFunctionInstance.ReduceMin;
case Tokens.SADD:
return MonadicFunctionInstance.ScanAdd;
case Tokens.SMULTIPLY:
return MonadicFunctionInstance.ScanMultiply;
case Tokens.SMIN:
return MonadicFunctionInstance.ScanMin;
case Tokens.SMAX:
return MonadicFunctionInstance.ScanMax;
case Tokens.SAND:
return MonadicFunctionInstance.ScanAnd;
case Tokens.SOR:
return MonadicFunctionInstance.ScanOr;
#endregion
#region Bitwise Operator
case Tokens.BWNOT:
return MonadicFunctionInstance.BitwiseNot;
#endregion
default:
return null;
}
}
/// <summary>
/// Converts a Monadic token to a Dyadic Token. If no conversion is available then the Token is not modified
/// </summary>
/// <param name="token"></param>
/// <returns>True if there was a conversion otherwise false</returns>
internal static bool ConvertToDyadicToken(Token token)
{
if (ReWriteRules.ContainsKey(token.Type))
{
token.Type = ReWriteRules[token.Type];
return true;
}
return false;
}
/// <summary>
/// Return the A+ native dyadic function for the specified dyadic token.
/// </summary>
/// <returns><b>null</b> if no dyadic function found</returns>
internal static AbstractDyadicFunction GetDyadicMethod(Token token)
{
switch (token.Type)
{
#region Dyadic Scalar
case Tokens.ADD:
return DyadicFunctionInstance.Add;
case Tokens.AND:
return DyadicFunctionInstance.And;
case Tokens.CIRCLE:
return DyadicFunctionInstance.Circle;
case Tokens.COMBINESYMBOLS:
return DyadicFunctionInstance.CombineSymbols;
case Tokens.DIVIDE:
return DyadicFunctionInstance.Divide;
case Tokens.EQUAL:
return DyadicFunctionInstance.EqualTo;
case Tokens.GT:
return DyadicFunctionInstance.GreaterThan;
case Tokens.GTE:
return DyadicFunctionInstance.GreaterThanOrEqualTo;
case Tokens.LOG:
return DyadicFunctionInstance.Log;
case Tokens.LT:
return DyadicFunctionInstance.LessThan;
case Tokens.LTE:
return DyadicFunctionInstance.LessThanOrEqualTo;
case Tokens.MAX:
return DyadicFunctionInstance.Max;
case Tokens.MIN:
return DyadicFunctionInstance.Min;
case Tokens.MULTIPLY:
return DyadicFunctionInstance.Multiply;
case Tokens.NOTEQUAL:
return DyadicFunctionInstance.NotEqualTo;
/*case Tokens.OR:
//Cast nonscalar primitive functon has not implementeted yet!
return DyadicFunctionInstance.Or;
return DyadicFunctionInstance.Cast;*/
case Tokens.POWER:
return DyadicFunctionInstance.Power;
case Tokens.RESIDUE:
return DyadicFunctionInstance.Residue;
case Tokens.SUBTRACT:
return DyadicFunctionInstance.Subtract;
#endregion
#region Dyadic Non Scalar
case Tokens.BINS:
return DyadicFunctionInstance.Bins;
case Tokens.CATENATE:
return DyadicFunctionInstance.Catenate;
case Tokens.CHOOSE:
return DyadicFunctionInstance.Choose;
case Tokens.DEAL:
return DyadicFunctionInstance.Deal;
case Tokens.DECODE:
return DyadicFunctionInstance.Decode;
case Tokens.DROP:
return DyadicFunctionInstance.Drop;
case Tokens.ENCODE:
return DyadicFunctionInstance.Encode;
case Tokens.EXECUTEINCONTEXT:
return DyadicFunctionInstance.ExecuteInContext;
case Tokens.EXPAND:
return DyadicFunctionInstance.Expand;
case Tokens.FORMAT:
return DyadicFunctionInstance.Format;
case Tokens.FIND:
return DyadicFunctionInstance.Find;
case Tokens.LAMINATE:
return DyadicFunctionInstance.Laminate;
case Tokens.LEFT:
return DyadicFunctionInstance.Left;
case Tokens.MAP:
return DyadicFunctionInstance.Map;
case Tokens.MATCH:
return DyadicFunctionInstance.Match;
case Tokens.MEMBER:
return DyadicFunctionInstance.Member;
case Tokens.PARTITION:
return DyadicFunctionInstance.Partition;
case Tokens.PICK:
return DyadicFunctionInstance.Pick;
case Tokens.REPLICATE:
return DyadicFunctionInstance.Replicate;
case Tokens.RESHAPE:
return DyadicFunctionInstance.Reshape;
case Tokens.RESTRUCTURE:
return DyadicFunctionInstance.Restructure;
case Tokens.ROTATE:
return DyadicFunctionInstance.Rotate;
case Tokens.SOLVE:
return DyadicFunctionInstance.Solve;
case Tokens.TAKE:
return DyadicFunctionInstance.Take;
case Tokens.TRANSPOSEAXES:
return DyadicFunctionInstance.TransposeAxis;
case Tokens.VALUEINCONTEXT:
return DyadicFunctionInstance.ValueInContext;
#endregion
#region Inner Products
case Tokens.IPADDMULTIPLY:
return DyadicFunctionInstance.IPAddMultiply;
case Tokens.IPMAXADD:
return DyadicFunctionInstance.IPMaxAdd;
case Tokens.IPMINADD:
return DyadicFunctionInstance.IPMinAdd;
#endregion
#region Outer Products
case Tokens.OPADD:
return DyadicFunctionInstance.OPAdd;
case Tokens.OPDIVIDE:
return DyadicFunctionInstance.OPDivide;
case Tokens.OPEQUAL:
return DyadicFunctionInstance.OPEqual;
case Tokens.OPGT:
return DyadicFunctionInstance.OPGreater;
case Tokens.OPGTE:
return DyadicFunctionInstance.OPGreaterEqual;
case Tokens.OPLT:
return DyadicFunctionInstance.OPLess;
case Tokens.OPLTE:
return DyadicFunctionInstance.OPLessEqual;
case Tokens.OPMAX:
return DyadicFunctionInstance.OPMax;
case Tokens.OPMIN:
return DyadicFunctionInstance.OPMin;
case Tokens.OPMULTIPLY:
return DyadicFunctionInstance.OPMultiply;
case Tokens.OPNOTEQUAL:
return DyadicFunctionInstance.OPNotEqual;
case Tokens.OPPOWER:
return DyadicFunctionInstance.OPPower;
case Tokens.OPRESIDUE:
return DyadicFunctionInstance.OPResidue;
case Tokens.OPSUBSTRACT:
return DyadicFunctionInstance.OPSubtract;
#endregion
#region Bitwise Operators
case Tokens.BWAND:
return DyadicFunctionInstance.BitwiseAnd;
case Tokens.BWOR:
return DyadicFunctionInstance.BitwiseOr;
case Tokens.BWLESS:
return DyadicFunctionInstance.BitwiseLess;
case Tokens.BWLESSEQUAL:
return DyadicFunctionInstance.BitwiseLessEqual;
case Tokens.BWEQUAL:
return DyadicFunctionInstance.BitwiseEqual;
case Tokens.BWGREATEREQUAL:
return DyadicFunctionInstance.BitwiseGreaterEqual;
case Tokens.BWGREATER:
return DyadicFunctionInstance.BitwiseGreater;
case Tokens.BWNOTEQUAL:
return DyadicFunctionInstance.BitwiseNotEqual;
#endregion
default:
return null;
}
}
public static RankOperator RankOperator(Token opToken)
{
RankOperator op = new RankOperator(null, null);
op.OperatorToken = opToken;
return op;
}
/// <summary>
/// Build a <see cref="DyadicFunction"/> using the given arguments.
/// </summary>
/// <param name="token">The <see cref="Token"/> to use for the dyadic function.</param>
/// <param name="leftExpression">The left hand argument of the dyadic function.</param>
/// <param name="rightExpression">The right hand argument of the dyadic function.</param>
/// <returns>Returns a <see cref="DyadicFunction"/> representing a built-in function.</returns>
public static Node DyadicFunction(Token token, Node leftExpression, Node rightExpression)
{
return new DyadicFunction(token, leftExpression, rightExpression);
}
/// <summary>
/// Builds a <see cref="Node"/> representing a built-in monadic function.
/// </summary>
/// <param name="token">The <see cref="Token"/> to use for the monadic function.</param>
/// <param name="expression">The argument of the monadic function.</param>
/// <returns>Returns a <see cref="MonadicFunction"/> representing a built-in function.</returns>
public static Node MonadicFunction(Token token, Node expression)
{
return new MonadicFunction(token, expression);
}
/// <summary>
/// Initializes a new instance of <see cref="MonadicFunction"/> AST node.
/// </summary>
/// <param name="token">The <see cref="Token"/> to use for the monadic function.</param>
/// <param name="expression">The argument of the monadic function.</param>
public MonadicFunction(Token token, Node expression)
{
this.token = token;
this.expression = expression;
}
public static EachOperator EachOperator(Token opToken)
{
EachOperator op = new EachOperator(null);
op.OperatorToken = opToken;
return op;
}
private static DLR.Expression BuildDyadicCase(
Token functionToken,
DLR.LabelTarget returnTarget,
DLR.Expression environment,
DLR.Expression rightParam,
DLR.Expression leftParam)
{
DLR.Expression result;
MethodInfo method = typeof(AbstractDyadicFunction).GetMethod("Execute");
if (functionToken.Type == Tokens.TYPE)
{
result = DLR.Expression.IfThenElse(
// $left.IsNumber || ($left.Type == ATypes.ANull)
DLR.Expression.OrElse(
DLR.Expression.IsTrue(
DLR.Expression.PropertyOrField(leftParam, "IsNumber")
),
DLR.Expression.Equal(
DLR.Expression.PropertyOrField(leftParam, "Type"),
DLR.Expression.Constant(ATypes.ANull)
)
),
// Or($right, $left)
DLR.Expression.Goto(
returnTarget,
DLR.Expression.Call(
DLR.Expression.Constant(DyadicFunctionInstance.Or),
method,
rightParam, leftParam, environment
)
),
// Cast($right, $left)
DLR.Expression.Goto(
returnTarget,
DLR.Expression.Call(
DLR.Expression.Constant(DyadicFunctionInstance.Cast),
method,
rightParam, leftParam, environment
)
)
);
}
else
{
MethodChooser.ConvertToDyadicToken(functionToken);
AbstractDyadicFunction dyadic = MethodChooser.GetDyadicMethod(functionToken);
if (dyadic != null)
{
result =
DLR.Expression.Goto(
returnTarget,
DLR.Expression.Call(
DLR.Expression.Constant(dyadic),
method,
rightParam,
leftParam,
environment
)
);
}
else
{
result =
DLR.Expression.Throw(
DLR.Expression.New(
typeof(Error.Valence).GetConstructor(new Type[] { typeof(string) }),
DLR.Expression.Constant(functionToken.Text)
)
);
}
}
return result;
}
/// <summary>
/// Initializes a new instance of <see cref="BuiltInFunction"/> AST node.
/// </summary>
/// <param name="function">The <see cref="AST.Token"/> to wrap.</param>
public BuiltInFunction(Token function)
{
this.function = function;
}
/// <summary>
/// Build a AST node which represents a standalone built-in function.
/// </summary>
/// <param name="token">The <see cref="AST.Token"/> to build the function from.</param>
/// <returns><see cref="AST.BuiltInFunction"/> AST node.</returns>
public static BuiltInFunction BuiltInFunction(Token token)
{
return new BuiltInFunction(token);
}
private static DLR.Expression BuildMonadicCase(
Token functionToken,
DLR.LabelTarget methodReturnTarget,
DLR.ParameterExpression methodEnvArg,
DLR.ParameterExpression methodRightArg)
{
DLR.Expression result;
AbstractMonadicFunction monadic = MethodChooser.GetMonadicMethod(functionToken);
if (monadic != null)
{
result = DLR.Expression.Goto(
methodReturnTarget,
DLR.Expression.Call(
DLR.Expression.Constant(monadic),
monadic.GetType().GetMethod("Execute"),
methodRightArg,
methodEnvArg
)
);
}
else
{
result = DLR.Expression.Throw(
DLR.Expression.New(
typeof(Error.Valence).GetConstructor(new Type[] { typeof(string) }),
DLR.Expression.Constant(functionToken.Text)
)
);
}
return result;
}