public int 条件_less(string expression)
{
var node = new Node(expression);
node.Parse();
return(Node.Compute(node));
}
public int 計算_if(string expression)
{
var row = new Dictionary <string, int>()
{
{ "X", 4 }, { "Y", 2 }
};
var tbl = new[]
{
new Dictionary <string, int>()
{
{ "A", 1 }, { "B", 3 }
},
new Dictionary <string, int>()
{
{ "A", 2 }, { "B", 6 }
},
new Dictionary <string, int>()
{
{ "A", 3 }, { "B", 7 }
},
};
var node = new Node(expression);
node.Parse();
return(Node.Compute(node, row, tbl));
}
public int 計算_カラム(string expression)
{
var row = new Dictionary <string, int>()
{
{ "A", 1 }, { "B", 2 }
};
var tbl = new[]
{
new Dictionary <string, int>()
{
{ "A", 1 }
},
new Dictionary <string, int>()
{
{ "A", 2 }
},
new Dictionary <string, int>()
{
{ "A", 3 }
},
};
var node = new Node(expression);
node.Parse();
var ans = Node.Compute(node, row, tbl);
return(ans);
}
public void parse_１項_1()
{
var node = new Node("2");
node.Parse();
Assert.True(node.Expression == "2");
Assert.True(node.Type == NodeType.Constant);
return;
}
public void parse_１項_3()
{
var node = new Node("-2");
node.Parse();
Assert.True(node.Expression == "-");
Assert.True(node.Right.Expression == "2");
return;
}
public int 計算(string expression)
{
var node = new Node(expression);
node.Parse();
//var ans = node.Compute();
var ans = Node.Compute(node);
return(ans);
}
public void parse_１項_2()
{
var node = new Node("+2");
node.Parse();
Assert.True(node.Expression == "+");
Assert.True(node.Type == NodeType.Operator);
Assert.True(node.Right.Expression == "2");
return;
}
public void parse_関数_２項()
{
var node = new Node("SUM(2,3)");
node.Parse();
Assert.True(node.Expression == "SUM");
Assert.True(node.Type == NodeType.Function);
Assert.True(node.Left.Expression == "2");
Assert.True(node.Right.Expression == "3");
}
public void parse_関数_１項_1()
{
var node = new Node("SUM(2)");
node.Parse();
{
Assert.True(node.Left.Expression == "2");
}
Assert.True(node.Expression == "SUM");
Assert.True(node.Right == null);
return;
}
public void parse_３項カッコあり()
{
var node = new Node("(2+3+4)");
node.Parse();
Assert.True(node.Left.Expression == "2");
Assert.True(node.Expression == "+");
Assert.True(node.Right.Left.Expression == "3");
Assert.True(node.Right.Expression == "+");
Assert.True(node.Right.Right.Expression == "4");
return;
}
public void parse_関数_１項_2()
{
var node = new Node("SUM(-2)");
node.Parse();
Assert.True(node.Expression == "SUM");
Assert.True(node.Type == NodeType.Function);
Assert.True(node.Left.Expression == "-");
{
Assert.True(node.Left.Left == null);
Assert.True(node.Left.Right.Expression == "2");
}
Assert.True(node.Right == null);
}
public void parse_関数_１項_2()
{
var node = new Node("SUM(-2)");
node.Parse();
Assert.True(node.Expression == "SUM");
Assert.True(node.Type == NodeType.Function);
Assert.True(node.Left.Expression == "-");
{
Assert.True(node.Left.Left == null);
Assert.True(node.Left.Right.Expression == "2");
}
Assert.True(node.Right == null);
}
public void parse_関数_１項_1()
{
var node = new Node("SUM(2)");
node.Parse();
{
Assert.True(node.Left.Expression == "2");
}
Assert.True(node.Expression == "SUM");
Assert.True(node.Right == null);
return;
}
public void parse_2項変数()
{
var node = new Node("2+abc");
node.Parse();
Assert.True(node.Left.Expression == "2");
Assert.True(node.Left.Type == NodeType.Constant);
Assert.True(node.Expression == "+");
Assert.True(node.Type == NodeType.Operator);
Assert.True(node.Right.Expression == "abc");
Assert.True(node.Right.Type == NodeType.Item);
return;
}
public void parse_2項変数()
{
var node = new Node("2+abc");
node.Parse();
Assert.True(node.Left.Expression == "2");
Assert.True(node.Left.Type == NodeType.Constant);
Assert.True(node.Expression == "+");
Assert.True(node.Type == NodeType.Operator);
Assert.True(node.Right.Expression == "abc");
Assert.True(node.Right.Type == NodeType.Item);
return;
}
public void parse_関数引数取得1()
{
var node = new Node("SUM(2,3+4,5)");
node.Parse();
var nodes = Node.GetArgumentNodes(node);
Assert.True(nodes [0].Type == NodeType.Constant);
Assert.True(nodes [0].Expression == "2");
Assert.True(nodes [1].Type == NodeType.Operator);
Assert.True(nodes [1].Expression == "+");
{
Assert.True(nodes [1].Left.Expression == "3");
Assert.True(nodes [1].Right.Expression == "4");
}
Assert.True(nodes [2].Type == NodeType.Constant);
Assert.True(nodes [2].Expression == "5");
}
public void parse_4項カッコあり()
{
var node = new Node("(2+3+4)+5");
node.Parse();
{
Assert.True(node.Left.Left.Expression == "2");
Assert.True(node.Left.Expression == "+");
{
Assert.True(node.Left.Right.Left.Expression == "3");
Assert.True(node.Left.Right.Expression == "+");
Assert.True(node.Left.Right.Right.Expression == "4");
}
}
Assert.True(node.Expression == "+");
Assert.True(node.Right.Expression == "5");
return;
}
public void parse_関数_３項()
{
var node = new Node("SUM(2,3+4,5)");
node.Parse();
Assert.True(node.Expression == "SUM");
Assert.True(node.Type == NodeType.Function);
Assert.True(node.Left.Expression == "2");
Assert.True(node.Right.Expression == ",");
{
Assert.True(node.Right.Left.Expression == "+");
{
Assert.True(node.Right.Left.Left.Expression == "3");
Assert.True(node.Right.Left.Right.Expression == "4");
}
Assert.True(node.Right.Right.Expression == "5");
}
var nodes = Node.GetArgumentNodes(node);
}
public int 計算(string expression)
{
var node = new Node(expression);
node.Parse();
//var ans = node.Compute();
var ans = Node.Compute(node);
return ans;
}
public int 条件_less(string expression)
{
var node = new Node(expression);
node.Parse();
return Node.Compute(node);
}
public void parse_３項()
{
var node = new Node("2+3+4");
node.Parse();
Assert.True(node.Left.Expression == "2");
Assert.True(node.Expression == "+");
Assert.True(node.Right.Left.Expression == "3");
Assert.True(node.Right.Expression == "+");
Assert.True(node.Right.Right.Expression == "4");
return;
}
public void parse_２項()
{
var node = new Node("2+3");
node.Parse();
Assert.True(node.Left.Expression == "2");
Assert.True(node.Expression == "+");
Assert.True(node.Type == NodeType.Operator);
Assert.True(node.Right.Expression == "3");
return;
}
public void parse_関数引数取得2()
{
var node = new Node("SUM(2,3+4,-5)");
node.Parse();
var nodes = Node.GetArgumentNodes(node);
Assert.True(nodes [ 0 ].Type == NodeType.Constant);
Assert.True(nodes [ 0 ].Expression == "2");
Assert.True(nodes [ 1 ].Type == NodeType.Operator);
Assert.True(nodes [ 1 ].Expression == "+");
{
Assert.True(nodes [ 1 ].Left.Expression == "3");
Assert.True(nodes [ 1 ].Right.Expression == "4");
}
Assert.True(nodes [ 2 ].Type == NodeType.Operator);
Assert.True(nodes [ 2 ].Expression == "-");
{
Assert.True(nodes [ 2 ].Left == null);
Assert.True(nodes [ 2 ].Right.Expression == "5");
}
}
public void parse_関数_３項()
{
var node = new Node("SUM(2,3+4,5)");
node.Parse();
Assert.True(node.Expression == "SUM");
Assert.True(node.Type == NodeType.Function);
Assert.True(node.Left.Expression == "2");
Assert.True(node.Right.Expression == ",");
{
Assert.True(node.Right.Left.Expression == "+");
{
Assert.True(node.Right.Left.Left.Expression == "3");
Assert.True(node.Right.Left.Right.Expression == "4");
}
Assert.True(node.Right.Right.Expression == "5");
}
var nodes = Node.GetArgumentNodes(node);
}
public void parse_関数_２項()
{
var node = new Node("SUM(2,3)");
node.Parse();
Assert.True(node.Expression == "SUM");
Assert.True(node.Type == NodeType.Function);
Assert.True(node.Left.Expression == "2");
Assert.True(node.Right.Expression == "3");
}
/// <summary>
/// 式解析
/// </summary>
/// <remarks>再帰的に呼び出される</remarks>
public void Parse()
{
int pos = GetOperatorPosition((this.Expression));
// 符号として+-が指定されるケース
if (pos == 0)
{
// TODO いきなり+-以外の演算子が出現したら異常
this.Left = null;
this.Right = new Node(this.Expression.Substring(pos + 1));
this.Right.Parse();
this.Expression = this.Expression[pos].ToString();
this.Type = NodeType.Operator;
}
// 「項 演算子 項」のケース
else if (pos > 0)
{
this.Left = new Node(this.Expression.Substring(0, pos));
this.Left.Parse();
this.Right = new Node(this.Expression.Substring(pos + 1));
this.Right.Parse();
this.Expression = this.Expression [pos].ToString();
this.Type = NodeType.Operator;
}
// 関数「Func(項・・・）」のケース
else if (IsFunction(this.Expression) == true)
{
// 関数名だけをExpressionとして保存する。本当は属性を何か持ちたい
var functionName = (new Regex(@"^" + functionMatcher)).Match(this.Expression).ToString();
if (functionDictionary.ContainsKey(functionName) == false)
{
throw new Exception("サポートされていない関数名が指定されています（" + functionName + "）");
}
else
{
// 一旦オペランド部を解析する
var operandNode = new Node(Regex.Replace(Expression, @"^(" + functionMatcher + @")\((.+)\)$", "$2"));
operandNode.Parse();
// 多項の引数の場合
if (operandNode.Expression == ",")
{
this.Left = operandNode.Left;
this.Right = operandNode.Right;
}
// １項の引数の場合
else
{
this.Left = operandNode;
this.Right = null;
}
this.Expression = functionName;
this.Type = NodeType.Function;
}
}
// 式を含まないケース
else
{
if ((new Regex(@".*[^0-9].*")).IsMatch(this.Expression))
{
this.Type = NodeType.Item;
}
else
{
this.Type = NodeType.Constant;
}
}
return;
}
public int 計算_if(string expression)
{
var row = new Dictionary<string, int>() { { "X", 4 }, { "Y", 2 } };
var tbl = new[]
{
new Dictionary<string, int>() {{"A", 1},{"B", 3}},
new Dictionary<string, int>() {{"A", 2},{"B", 6}},
new Dictionary<string, int>() {{"A", 3},{"B", 7}},
};
var node = new Node(expression);
node.Parse();
return Node.Compute(node, row, tbl);
}
public int 計算_カラム(string expression)
{
var row = new Dictionary<string, int>() { { "A", 1 }, { "B", 2 } };
var tbl = new[]
{
new Dictionary<string, int>() {{"A", 1}},
new Dictionary<string, int>() {{"A", 2}},
new Dictionary<string, int>() {{"A", 3}},
};
var node = new Node(expression);
node.Parse();
var ans = Node.Compute(node, row, tbl);
return ans;
}
public void parse_１項_1()
{
var node = new Node("2");
node.Parse();
Assert.True(node.Expression == "2");
Assert.True(node.Type == NodeType.Constant);
return;
}
/// <summary>
/// 式解析
/// </summary>
/// <remarks>再帰的に呼び出される</remarks>
public void Parse()
{
int pos = GetOperatorPosition((this.Expression));
// 符号として+-が指定されるケース
if (pos == 0)
{
// TODO いきなり+-以外の演算子が出現したら異常
this.Left = null;
this.Right = new Node(this.Expression.Substring(pos + 1));
this.Right.Parse();
this.Expression = this.Expression[pos].ToString();
this.Type = NodeType.Operator;
}
// 「項 演算子 項」のケース
else if (pos > 0)
{
this.Left = new Node(this.Expression.Substring(0, pos));
this.Left.Parse();
this.Right = new Node(this.Expression.Substring(pos+1));
this.Right.Parse();
this.Expression = this.Expression [ pos ].ToString();
this.Type = NodeType.Operator;
}
// 関数「Func(項・・・）」のケース
else if (IsFunction(this.Expression) == true)
{
// 関数名だけをExpressionとして保存する。本当は属性を何か持ちたい
var functionName = ( new Regex(@"^"+functionMatcher) ).Match(this.Expression).ToString();
if (functionDictionary.ContainsKey(functionName) == false)
{
throw new Exception("サポートされていない関数名が指定されています（"+functionName+"）");
}
else
{
// 一旦オペランド部を解析する
var operandNode = new Node(Regex.Replace(Expression, @"^(" + functionMatcher +@")\((.+)\)$", "$2"));
operandNode.Parse();
// 多項の引数の場合
if (operandNode.Expression == ",")
{
this.Left = operandNode.Left;
this.Right = operandNode.Right;
}
// １項の引数の場合
else
{
this.Left = operandNode;
this.Right = null;
}
this.Expression = functionName;
this.Type = NodeType.Function;
}
}
// 式を含まないケース
else
{
if((new Regex(@".*[^0-9].*")).IsMatch(this.Expression) )
{
this.Type = NodeType.Item;
}else{
this.Type = NodeType.Constant;
}
}
return;
}
public void parse_１項_3()
{
var node = new Node("-2");
node.Parse();
Assert.True(node.Expression == "-");
Assert.True(node.Right.Expression == "2");
return;
}
